{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 分类训练"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 机器学习的HelloWorld ，一个新的分类算法，都会看看在MNIST的上的执行结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 解包byt文件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x00\\x00\\x00\\x02'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import struct\n",
    "# pack 将'2'打包成二进制数组或字符串\n",
    "# unpack 解压\n",
    "struct.pack('>B',2) #  只占一个字节\n",
    "struct.pack('>i',2) # 高位字节，占四个字节"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "![jupyter](./g1.png)\n",
    "\n",
    "![jupyter](./g2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2051, 60000, 28, 28)\n",
      "47040000\n"
     ]
    }
   ],
   "source": [
    "import struct\n",
    "with open('./MNIST_data/train-images-idx3-ubyte', 'rb') as f:\n",
    "    buffer = f.read(4*4) # 4个int\n",
    "    head = struct.unpack('>iiii',buffer)\n",
    "    print(head)\n",
    "    length = head[1] * head[2]  * head[3]\n",
    "    print(length)\n",
    "    buffer = f.read(length)\n",
    "#   print(buffer)\n",
    "    data = struct.unpack('>{}B'.format(length),buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47040000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "imgs = np.reshape(data, (head[1], head[2], head[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAMdUlEQVR4nO3dX6gc5R3G8eeJbRGiaDQYo02NFS9aio0lSMFQUkxDFCHxomIuSqTS40WVChUiVlAphVBri4gKp2j+lNZSiDahlKqEqC1B8SipxiapNkRNcjinIqK5SvX8enEmcoy7s8edmZ1Nft8PHHZ33t2ZH0OevO/M7M7riBCAU9+ctgsAMBiEHUiCsANJEHYgCcIOJPGFQW7MNqf+gYZFhDstr9Sz215le7/tN23fUWVdAJrlfq+z2z5N0r8lfU/SIUkvSVobEf8q+Qw9O9CwJnr2KyS9GREHIuKYpD9KWl1hfQAaVCXsF0p6Z8brQ8WyT7E9YnvM9liFbQGoqMoJuk5Dhc8M0yNiVNKoxDAeaFOVnv2QpEUzXn9Z0pFq5QBoSpWwvyTpUtsX2/6SpBskba+nLAB163sYHxEf2b5F0lOSTpP0WES8XltlAGrV96W3vjbGMTvQuEa+VAPg5EHYgSQIO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EAShB1IgrADSRB2IAnCDiRB2IEkCDuQBGEHkiDsQBKEHUiCsANJEHYgCcIOJEHYgSQIO5AEYQeSIOxAEn1P2Qw07a677iptv/fee0vb58zp3pctX7689LPPPfdcafvJqFLYbR+U9KGkjyV9FBFL6ygKQP3q6Nm/GxHv1rAeAA3imB1IomrYQ9LTtl+2PdLpDbZHbI/ZHqu4LQAVVB3GXxkRR2yfJ+kZ2/si4vmZb4iIUUmjkmQ7Km4PQJ8q9ewRcaR4nJT0pKQr6igKQP36DrvtubbPPP5c0kpJe+oqDEC9qgzjF0h60vbx9fwhIv5WS1VI4cYbbyxtX79+fWn71NRU39uOyHdE2XfYI+KApG/WWAuABnHpDUiCsANJEHYgCcIOJEHYgST4iStac9FFF5W2n3766QOqJAd6diAJwg4kQdiBJAg7kARhB5Ig7EAShB1IguvsaNSKFSu6tt16662V1r1v377S9muvvbZr28TERKVtn4zo2YEkCDuQBGEHkiDsQBKEHUiCsANJEHYgCa6zo5Jly5aVtm/cuLFr21lnnVVp2/fdd19p+1tvvVVp/acaenYgCcIOJEHYgSQIO5AEYQeSIOxAEoQdSILr7Khk3bp1pe0XXHBB3+t+9tlnS9u3bNnS97oz6tmz237M9qTtPTOWnWP7GdtvFI/zmi0TQFWzGcZvkrTqhGV3SNoREZdK2lG8BjDEeoY9Ip6X9N4Ji1dL2lw83yxpTc11AahZv8fsCyJiXJIiYtz2ed3eaHtE0kif2wFQk8ZP0EXEqKRRSbIdTW8PQGf9XnqbsL1QkorHyfpKAtCEfsO+XdLxay7rJG2rpxwATXFE+cja9uOSlkuaL2lC0t2S/izpT5K+IultSd+PiBNP4nVaF8P4k8z8+fNL23vdf31qaqpr2/vvv1/62euvv760fefOnaXtWUWEOy3vecweEWu7NF1VqSIAA8XXZYEkCDuQBGEHkiDsQBKEHUiCn7gmt3jx4tL2rVu3NrbtBx98sLSdS2v1omcHkiDsQBKEHUiCsANJEHYgCcIOJEHYgSS4zp7cqlUn3kv00y677LJK69+xY0fXtgceeKDSuvH50LMDSRB2IAnCDiRB2IEkCDuQBGEHkiDsQBI9byVd68a4lfTArVlTPg3fpk2bStvnzp1b2r5r167S9rLbQfe6DTX60+1W0vTsQBKEHUiCsANJEHYgCcIOJEHYgSQIO5AEv2c/BZTd+73J+75L0oEDB0rbuZY+PHr27LYfsz1pe8+MZffYPmx7d/F3TbNlAqhqNsP4TZI63c7kNxGxpPj7a71lAahbz7BHxPOS3htALQAaVOUE3S22Xy2G+fO6vcn2iO0x22MVtgWgon7D/oikSyQtkTQu6f5ub4yI0YhYGhFL+9wWgBr0FfaImIiIjyNiStJvJV1Rb1kA6tZX2G0vnPHyOkl7ur0XwHDoeZ3d9uOSlkuab/uQpLslLbe9RFJIOijp5gZrRA/r16/v2jY1NdXotjds2NDo+lGfnmGPiLUdFj/aQC0AGsTXZYEkCDuQBGEHkiDsQBKEHUiCn7ieBJYsWVLavnLlysa2vW3bttL2/fv3N7Zt1IueHUiCsANJEHYgCcIOJEHYgSQIO5AEYQeSYMrmk8Dk5GRp+7x5Xe8K1tMLL7xQ2n711VeXth89erTvbaMZTNkMJEfYgSQIO5AEYQeSIOxAEoQdSIKwA0nwe/aTwLnnnlvaXuV20Q8//HBpO9fRTx307EAShB1IgrADSRB2IAnCDiRB2IEkCDuQBNfZh8DGjRtL2+fMae7/5F27djW2bgyXnv+KbC+yvdP2Xtuv2/5Jsfwc28/YfqN47P8OCgAaN5su4yNJP42Ir0n6tqQf2/66pDsk7YiISyXtKF4DGFI9wx4R4xHxSvH8Q0l7JV0oabWkzcXbNkta01SRAKr7XMfsthdLulzSi5IWRMS4NP0fgu3zunxmRNJItTIBVDXrsNs+Q9JWSbdFxAd2x3vafUZEjEoaLdbBDSeBlszqNK/tL2o66L+PiCeKxRO2FxbtCyWV3wIVQKt69uye7sIflbQ3In49o2m7pHWSNhSP5XP7JtZryuUVK1aUtvf6CeuxY8e6tj300EOln52YmChtx6ljNsP4KyX9QNJrtncXy+7UdMj/ZPsmSW9L+n4zJQKoQ8+wR8Q/JHU7QL+q3nIANIWvywJJEHYgCcIOJEHYgSQIO5AEP3EdgLPPPru0/fzzz6+0/sOHD3dtu/322yutG6cOenYgCcIOJEHYgSQIO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EAShB1Igt+zD8C+fftK23tNm7xs2bI6y0FS9OxAEoQdSIKwA0kQdiAJwg4kQdiBJAg7kIQjovwN9iJJWySdL2lK0mhEPGD7Hkk/kvTf4q13RsRfe6yrfGMAKouIjrMuzybsCyUtjIhXbJ8p6WVJayRdL+loRPxqtkUQdqB53cI+m/nZxyWNF88/tL1X0oX1lgegaZ/rmN32YkmXS3qxWHSL7VdtP2Z7XpfPjNgesz1WqVIAlfQcxn/yRvsMSc9J+kVEPGF7gaR3JYWkn2t6qP/DHutgGA80rO9jdkmy/UVJf5H0VET8ukP7Ykl/iYhv9FgPYQca1i3sPYfxti3pUUl7Zwa9OHF33HWS9lQtEkBzZnM2fpmkv0t6TdOX3iTpTklrJS3R9DD+oKSbi5N5ZeuiZwcaVmkYXxfCDjSv72E8gFMDYQeSIOxAEoQdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EAShB1IgrADSRB2IIlBT9n8rqS3ZryeXywbRsNa27DWJVFbv+qs7aJuDQP9PftnNm6PRcTS1gooMay1DWtdErX1a1C1MYwHkiDsQBJth3205e2XGdbahrUuidr6NZDaWj1mBzA4bffsAAaEsANJtBJ226ts77f9pu072qihG9sHbb9me3fb89MVc+hN2t4zY9k5tp+x/Ubx2HGOvZZqu8f24WLf7bZ9TUu1LbK90/Ze26/b/kmxvNV9V1LXQPbbwI/ZbZ8m6d+SvifpkKSXJK2NiH8NtJAubB+UtDQiWv8Chu3vSDoqacvxqbVs/1LSexGxofiPcl5ErB+S2u7R55zGu6Hauk0zfqNa3Hd1Tn/ejzZ69iskvRkRByLimKQ/SlrdQh1DLyKel/TeCYtXS9pcPN+s6X8sA9eltqEQEeMR8Urx/ENJx6cZb3XfldQ1EG2E/UJJ78x4fUjDNd97SHra9su2R9oupoMFx6fZKh7Pa7meE/WcxnuQTphmfGj2XT/Tn1fVRtg7TU0zTNf/royIb0m6WtKPi+EqZucRSZdoeg7AcUn3t1lMMc34Vkm3RcQHbdYyU4e6BrLf2gj7IUmLZrz+sqQjLdTRUUQcKR4nJT2p6cOOYTJxfAbd4nGy5Xo+ERETEfFxRExJ+q1a3HfFNONbJf0+Ip4oFre+7zrVNaj91kbYX5J0qe2LbX9J0g2StrdQx2fYnlucOJHtuZJWavimot4uaV3xfJ2kbS3W8inDMo13t2nG1fK+a33684gY+J+kazR9Rv4/kn7WRg1d6vqqpH8Wf6+3XZukxzU9rPufpkdEN0k6V9IOSW8Uj+cMUW2/0/TU3q9qOlgLW6ptmaYPDV+VtLv4u6btfVdS10D2G1+XBZLgG3RAEoQdSIKwA0kQdiAJwg4kQdiBJAg7kMT/AR1U3JCzCjB2AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "for i in range(5):\n",
    "    plt.imshow(imgs[i], cmap = 'gray')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 解包mat文件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import fetch_mldata\n",
    "mnist = fetch_mldata('MNIST original', data_home='./')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'DESCR': 'mldata.org dataset: mnist-original',\n",
       " 'COL_NAMES': ['label', 'data'],\n",
       " 'target': array([0., 0., 0., ..., 9., 9., 9.]),\n",
       " 'data': array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* DESCR 数据集描述\n",
    "* data 包含一个数组，每个实例为一行，每个特征为一列\n",
    "* target 包含一个带有标签的数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = mnist['data'], mnist['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000, 784)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000,)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_digit = X[36000]\n",
    "some_digit_image = some_digit.reshape(28, 28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(some_digit_image, cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[36000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立测试集和训练集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20638, 51951, 46170, ...,  9772, 32170,  8267])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将数据集合交叉洗牌，交叉验证时，每个子集合数据分布均匀，有些机器学习算法对训练实例的顺序敏感\n",
    "import numpy as np\n",
    "shuffle_index = np.random.permutation(60000)\n",
    "shuffle_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train = X_train[shuffle_index], y_train[shuffle_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练一个二元分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False,  True, False])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 识别数字5 ，二元分类5或者非5\n",
    "# 创建目标向量\n",
    "y_train_5 = (y_train == 5)\n",
    "y_train_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False,  True],\n",
       "       [False,  True, False, ..., False, False, False],\n",
       "       ...,\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [ True, False, False, ..., False,  True, False]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_5.reshape(20, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_5 = (y_test == 5) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SGD 梯度下降 分类器， 适合非常大的数据集，独立处理训练集数据，一次一个，适合在线学习，\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "\n",
    "sgd_clf = SGDClassifier(random_state = 42)\n",
    "sgd_clf.fit(X_train, y_train_5)\n",
    "\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 性能考核"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用交叉验证测量精度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.9675 , 0.96445, 0.92425])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估分类器比评估回归器要困难得多\n",
    "\n",
    "# 3个折叠，正确率达到 95% 以上\n",
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把每张图都分类成 非5\n",
    "from sklearn.base import BaseEstimator\n",
    "class Never5Classifier(BaseEstimator):\n",
    "    def fit(self, X, y=None):\n",
    "        pass\n",
    "    def predict(self, X):\n",
    "        return np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False],\n",
       "       [False],\n",
       "       [False],\n",
       "       ...,\n",
       "       [False],\n",
       "       [False],\n",
       "       [False]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.90855, 0.91005, 0.91035])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "never_5_clf = Never5Classifier()\n",
    "cross_val_score(never_5_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 准确率超过90% ，因为5的图像大约只有10%，你猜一张图不是5， 90%的时间你都是正确的\n",
    "* 这说明准确率无法成为分类器的首要性能指标，特别是当你处理偏科数据集， 某些类比其他类更为频繁"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 评估分类器性能的更好方法是混淆矩阵\n",
    "# A类别实例被分为B类别次数\n",
    "# 想要知道分类器将数字3和数字5混淆多少次，通过混淆矩阵的5行3列\n",
    "from sklearn.model_selection import cross_val_predict\n",
    "\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 与 cross_val_score 相比\n",
    "* 同样执行交叉验证\n",
    "* 返回的不是评估分数，是每个折叠的预测\n",
    "* 每一个实例在模型预测时使用的数据，在训练期间从未见过"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[52813,  1766],\n",
       "       [ 1110,  4311]], dtype=int64)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "confusion_matrix(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 行表示实际类别，列表示预测类别\n",
    "# 第一行 第一列 53272 被正确的分为 非5 ，真负类\n",
    "# 第一行 第二列 1307 被错误的分类成 5 ，假正类\n",
    "# 第二行 第一列 1077 张被错误的分为 非5， 假负类\n",
    "# 第二行 第二列 4344 张被正确的分在了5 ，真正类\n",
    "# 这种衡量方式太复杂，我们可以用更简单的指标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54579,     0],\n",
       "       [    0,  5421]], dtype=int64)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_perfect_predictions = y_train_5\n",
    "confusion_matrix(y_train_5, y_train_perfect_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "## 正类预测的准确率 被称为分类器的精度\n",
    "\n",
    "\n",
    "$\n",
    "\\text{精度} = \\cfrac{TP}{TP + FP}\n",
    "$\n",
    "\n",
    "TP是真正类的数量，FP是假正类的数量\n",
    "\n",
    "\n",
    "\n",
    "$\n",
    "\\text{召回率TPR} = \\cfrac{TP}{TP + FN}\n",
    "$\n",
    "* 检测正类实例的比例\n",
    "FN是假负类的数量\n",
    "![jupyter](./zhaohui.jpg)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度和召回率\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7093960835938785"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score, recall_score\n",
    "\n",
    "precision_score(y_train_5, y_train_pred) # 4327 / 4327 + 1276"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7952407304925291"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred)    #  4327 / 4327 + 1094"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 说明 检测一张图的时候，只有71%的概率是准确的，而且只有80%的数字5 被它检测出来\n",
    "# 精度和召回率合成单一指标，成为 F1 分数，谐波平均值\n",
    "# 平均值平等对待所有的值，谐波平均值会给予较低值更高的权重，只有召回率和精度都很高时，才能获得较高的F1分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "F_1 = \\cfrac{2}{\\cfrac{1}{\\text{precision}} + \\cfrac{1}{\\text{recall}}} = 2 \\times \\cfrac{\\text{precision}\\, \\times \\, \\text{recall}}{\\text{precision}\\, + \\, \\text{recall}} = \\cfrac{TP}{TP + \\cfrac{FN + FP}{2}}\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7498695425291354"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "f1_score(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# F1分数对那些具有相近精度和召回率 分类器更有利，这不一定符合你的期望\n",
    "# 有时候你更关心精度，有时你能关心召回率\n",
    "# 训练一个分类器检测儿童可以放心观看的视频，你可能要求拦截了很多好的视频，低召回率，保留下来的都是安全的视频，高精度\n",
    "# 不能同时增加精度并减少召回率，反之亦然"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度/召回率权衡"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "![jupyter](./quanheng.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* SGDClassifier对每个实例基于决策函数计算一个分值，大于阀值为正类，否则为负类\n",
    "* 中间阀值右侧找到4个真正类 真5 ， 一个假正类 6， 精度为 4/5 80%\n",
    "* 在所有的6个 真正的5 中，分类器找到了4个，召回率为 4/6 67%\n",
    "* 提高阀值，向右移动，精度提高，召回降低\n",
    "* 反之阀值降低，召回提高，精度降低\n",
    "* SKlearn不可以直接设置阀值，可以访问决策分数，\n",
    "* SGDClassifier 默认阀值为0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何设置阀值\n",
    "\n",
    "# 用predict_proba得到每个实例属于正类的概率，然后对概率切一下。以LogisticRegression为例\n",
    "# clf = LogisticRegression()\n",
    "# clf.fit(X_train, y_train)\n",
    "# pred_proba = clf.predict_proba(X_test)[:, 1]\n",
    "# threshold = 0.75  # 阀值设置为0.75\n",
    "# pred_label = pred_proba > threshold\n",
    "\n",
    "# pred_proba是每个实例为真的概率\n",
    "# 假设阈值是0.75\n",
    "# pred_label里True就是概率大于0.75的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([38178.80435509])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回决策值decision_function\n",
    "y_scores = sgd_clf.decision_function([some_digit])\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold = 0\n",
    "y_some_digit_pred = (y_scores > threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 提高阀值可以降低召回率，提高阀值到200000，就错了这个图\n",
    "threshold = 200000\n",
    "y_some_digit_pred = (y_scores > threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 如何决定使用什么阀值\n",
    "# 返回决策值，而不是预测结果\n",
    "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,\n",
    "                             method=\"decision_function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000,)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 有了y_scores，可以计算所有可能的阀值的精度和召回率\n",
    "y_scores.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_recall_curve\n",
    "\n",
    "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib 绘制精度和召回相对于阀值的函数图\n",
    "def plot_precision_recall_vs_threshold(precisions, recalls, QA):\n",
    "    plt.plot(thresholds, precisions[:-1], \"b--\", label=\"Precision\", linewidth=2)\n",
    "    plt.plot(thresholds, recalls[:-1], \"g-\", label=\"Recall\", linewidth=2)\n",
    "    plt.xlabel(\"Threshold\", fontsize=16)\n",
    "    plt.legend(loc=\"upper left\", fontsize=16)\n",
    "    plt.ylim([0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n",
    "plt.xlim([-700000, 700000])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_precision_vs_recall(precisions, recalls):\n",
    "    plt.plot(recalls, precisions, \"b-\", linewidth=2)\n",
    "    plt.xlabel(\"召回\", fontsize=16)\n",
    "    plt.ylabel(\"精度\", fontsize=16)\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_precision_vs_recall(precisions, recalls)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通过选择阀值来实现最佳的精度/召回率权衡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 目标设定为90%的精度，阀值大概在30000左右 , 设置了阀值为30000\n",
    "y_train_pred_90 = (y_scores > 200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9190053285968028"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train_5, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.47721822541966424"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 获得了一个92%精度的分类器，但如果召回太低，精度再高，也不怎么有用\n",
    "* 如果工作中，需要99%的精度，你应该回应，召回率是多少？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC 曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 本质是 真正类率tpr和假正类率fpr（错误的分为正类的负类实例比例）\n",
    "# 与召回/精度曲线非常相似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve\n",
    "\n",
    "fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf0AAAF6CAYAAAATeYHoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3xUVf7/8deZSW8kSAIGEUFRpBiECCoqCFIs61opUhYURV3dXdwvVlBEdHX1y/q1rwoCuoC4v7WsBRFRrJSABgsqIh3pkF5nzu+PmSAikASSuZk77+fjwWYyc+feD1nMe865pxhrLSIiIuJ+HqcLEBERkdBQ6IuIiEQIhb6IiEiEUOiLiIhECIW+iIhIhFDoi4iIRAiFvoiISIQIeegbY5oaYz4+xOvRxpj/GmM+NcZcHcraRERE3CykoW+MSQOmA4mHOOxmYJm1tjtwhTEmOSTFiYiIuFyoW/o+YCCQf4hjegJzgo8/ArLruSYREZGIEBXKi1lr8wGMMYc6LBHYFHy8C2i6/wHGmOuA6wASExO7tG3btm4LFRGJYH5r8QdXaA+s1G73eQyV/n2Xb7d7n6/w+X/1+/2XVd7t3v+t9FksYEzgiapDKn1+fNbiMYbich8xXs+vzm2BorJKYqO9wfdZKnwWf/A9VXU7zez3jdnnGb+1xEZ5KKv0kxQbiN9KnyU+xvvLe82vz1Pu8xMf7aWyooJdWzZQXlpCQkoaxfm7d1hr02tbX0hDv4YKgXggD0gKfv8r1tpngWcBsrOzbU5OTkgLFBGpC36/pdIfCK4Kn589xRWB54Oha/f7urOoDI8x+G0gDP3W4gu+f+PuEhJiovae84etBWwrKCUlLhqfP3Dc2p1F+CwkRHtZs6OILfmlAMR4PfiC56pvhl8HY9XjmH2eiz3Ie2tzr7dRfDRej8FjDDsKyzipaTLGgMcYPJ7AV2MM1lo27yml87GpGAM7C8tpn5mCx2PwGkNeSQVNU+I4Ji2e1IRovB4P1lqaNYrDYwxNkmKJjfKQGBtFTFT9dJ4XFRXRunVr4mKimTHtBQYOHIgxZt3hnKshhv4y4Czg30AWsMjZckTEbXx+S1F5JUVllVT6AmG3s6gMawOtWL/f8nNeKVFeQ6XPsmF3MdFeD36/JXdjHkc3itsvmAOPP1m1g2PS4vHZwDmKyn38uK1w7/E+f+D4/NIKKnzOt0qrlPv8ex8b80sLvUlSLJ6qoDSBXlqPB3YUlJMY6+WYtIRgsAZ7cC1s3F1Mp2NTMSbQxg2Ea/ArgeN+ziuhVZNEkmKjMMbg9YDXGPJLK0lPjqVxYgxFZZW0PCoxcP1gAHs9gY8IjRNj9gZ6lMeQlhhDlCfwerTXs/e4cFdRUUF0dDSJiYk8/vjjnHbaabRq1eqIzulo6BtjegHtrLVP7PP0dOBtY8zZQDtgsSPFiUiDYq1lT3EFX2/Oo7C0kpIKH2t3FJEcF723ZbuzqByf3x9s/f7SQvb5LV9u2AP8OtTqQ1XreV8/5/32uSpRHoPHEwiv4nIfTZJiSYjx/hKU+wRmcbmPovJK2jZLDgZx4HWvJ/DhZHdxOe2OTiHKG3htV1E5zRrFcXKzlL3XKK3wcXRqPHFRgXA8tnECKcFWsdcEahHnffXVVwwaNIgJEyZw5ZVXMmDAgDo5ryOhb63tGfy6AFiw32vrjDF9CLT277bW+kJfoYjsz1pLebALuqo1DL90RQe6nC0FpZWUV/qp9Fs27CrGAqu3FZIcF83mPSWUVPhIiPFS6beUVfrJ3bCH45ok4g92U/v8ga7rJWt3ARAb5cEX7LKum7/Hr4O/eWo8Xo+hqKwSn7WcmJGMxxMI0nU7izntuMZ4PYbNe0rIapFKjNdDXkkFx2ck/bYVHOwubp2eGGyFejAm0NUc7fXsbbV6jCHKa0iJi66Tv5O4h7WWZ555hltuuYXU1FQaN25cp+dviN37WGs388sIfhE5AsXllWzcXcKWvNK9oVpYVsn2gjLiY7yBru4yH+t3FdM4MZpKn+XHbYVU+gNftxeU/ar7tz6s31V80NfKKn997Rivh3Kfn99lZeLz+ymr8HNCRhJRXsOe4graZabQ6qjEveFaFchejyEhxsvx6Umu6f4Vd9m1axfXXnst//nPf+jfvz/Tp08nIyOjTq/RIENfRA6tsKySTbtLAl3ahWUsXbcbjzFs3F2MtfDlhj0c2zjhkGF6JKK9hozkuF8GRPFLV7Qxhh+3FXLm8Ufh9Ri25JXSsXkjfNbSukkShWWBgVEpcYEuZUugi7vqPq0x7O1mbhQfzbGNA/eNozymupk/ImFt/vz5vPHGGzzyyCOMGTMGj6fuBwYq9EUaiK35pSxZs4tFP+0kKS6KpWt2cXRqPEvW7OKYtHi+WL+HJkkx7Cgsr9H59g38ZilxpCYEute7tEzD6/GQX1pBUmzU3u7tsko/HgMtGicQ5TEUlFbSqkkijRNjaJoSR8ujEoiL9tbXX18kIvl8PnJzc+ncuTMDBgwgOzub1q1b19v1FPoidWjDrmK+2pQHBEaB+/x+VmzMI6+4gm0FZcFRyPDp6p0cn55Ehc/Pj9sKiY/2UlJxgOEr6wODz7YXlAH8JvDjo710apHKMWnxVPotnVumERvl4djGCTSKjyY1IZrGiTHERimsRRqaTZs2MXToUBYtWsT333/PscceW6+BDwp9iXD7ju72B6delVb4KSqrpMLnZ1dROeU+P4WllazbWczStbvYVlBGXLSH0go/KzYGutG3FZRRXF67Macrf/5lYcqqwI+N8tClZRrGQK+2Tan0+Wl5VGDV6szUOOKjvaQlxpAUG6VWt0gYe/PNNxkxYgQlJSU8/fTTtGjRIiTXVeiLK/n8li35pazbUcSanUVsySvlyw17SE2IYdnaXWw+xBSq2lq787f3zZunxnPqsanBucMetheWcUrzRqQmBO5Rx0V7iYnykJYQQ5TXkJYQCPL6WtxDRBoGay233HILjz76KJ06dWL27NmcdNJJIbu+Ql/CRlmlj7ySCjbsKmb5uj0YAys25rG7uJxor4cVG/eQnhz3qxZ0TUVVjfT2BJbNLKnw0apJIl6PYf3OYrq1bkxBaSXJcVE0Towh+7jGtG6SuHdhkPhgiGckx2qwmYgclDEGr9fLn/70Jx566CHi4uJCen2FvjQo1lrW7ypm9fZCKnyWrzfl8c3mfD76YXuN5mkfaJBbWkI0manxtG2WQlpCNKcem0aU19AmI4nmafG63y0i9cpay4wZM2jTpg1nnnkmDz/8sGONA4W+hFSFz893Pxewensha3cW8eO2QjbsKiYu2svq7YU1GpnePDWeTcFR6Kcd15jCsgpapCXQOj2JaK+hWaM4UuNjaNYotJ+gRUT2V1BQwA033MC//vUvhg0bxplnnulob6BCX+pMfmkFG3eVBDb18FveyN1Manw0ryzbSOPEGPJLKmq1qlqXlmk0S4kjv7SC805uyu+yMmmcGFP9G0VEGoCcnBwGDRrEmjVruO+++7jjjjucLkmhL7VXWuHjuy0FrNpawLaCMh5+9/tq37Or6Nct+BMykiir9JF1TCoZyXG0apJAqyZJHNckgYzkOA1oE5GwtmTJEs466yyaNWvGwoULOeuss5wuCVDoy0FU+vy8+81Wvtywm1XbConxevj0xx0U1WBamsfA8elJdGjeCJ/f0qttBunJsbTPTCEmykNCjP7ZiYg7+f1+PB4PXbp0Ydy4cdx00011vn7+kdBvXwEgr6SCbzblMWvpBv6bu7lG74nxeujQPIUzj2/Cqcemcu5JGdqhS0Qi1vz587nllluYO3cumZmZ3H333U6X9BsK/QhTXuln9tL1FJf7+H5LASs27mH19qJDvufirExapyfSqkkiRyXGkn1cmhaGEREJqqio4O677+ahhx6ibdu25Ofnk5mZ6XRZB6TQdzlrLXO/3sKbX/3MWyt+rvb4k5omc3xGIjf0OIEOzVM051xE5BDWrFnD4MGDWbx4Mddeey2PPvooCQkJTpd1UAp9F/H5LcvX7+atFT+zenshX67fQ0FZ5UGPH92jNaXlPk5qlsJ57TLISNYUNxGR2pg4cSLfffcdL7/8MgMGDHC6nGoZa2s+haohys7Otjk5OU6X4ZgNu4qZk7OBZz/66Tf7ju+r5VEJ/L5Tczofm0rPk+p2f2YRkUhSXFzMrl27OOaYY9izZw+7d++mVatWIa3BGLPMWptd2/eppR9GrLVs2FXCm19t5p2vtuzdze1AerXNoEvLNLKOSeX01o2J8moKnIjIkfrqq68YOHAgiYmJLF68mNTUVFJTU50uq8YU+mFgW34pQ6cs5oethQc95uw2TbjunNacdUIT3YcXEalj1lqeeeYZxowZQ1paGo899hgeT/g1phT6DdSaHUXc8NIyvttS8JvXMhvFcUHHozkhI4n+HZqRmqBV6kRE6kteXh4jR47k1VdfpX///kyfPp2MjPC8TarQb2BWbS3gkic//c0iOMZA1jGp/Pv6M9RVLyISQjExMaxbt45HHnmEMWPGhGULv4pC32HWWpas2cVzH69h/sqtv3l9SLdjGXdhO+JjNC9eRCRUfD4fTzzxBFdffTXJycksXryYqKjwj8zw/xuEsQXfbeXqab+deZASF8WdF5zMoK7HOlCViEhk27hxI0OHDmXhwoXExcUxevRoVwQ+KPRDylrL+yu38dDc71i17beD8i7o2IxJl3TUTnIiIg7573//y8iRIyktLWXatGkMHz7c6ZLqlEI/BPYUl/PY+z8y9dM1v3nt/A7NmPj7DqQnxzpQmYiIVHnyySe56aabOPXUU5k1axYnnXSS0yXVOYV+Pfpk1Q7+8vKX7Cgs+9XzsVEeBnc9lpt7ncBRSQp7EZGG4KKLLmL9+vVMnDiR2Fh3/m7Winz14MXP1zL+9W9+8/yA7GMYd1E7UuKiQ1+UiIj8irWW6dOn88477zBr1qywGpWvFfkaiPvf+pbnPv51N/7MUd0484QmDlUkIiL7y8/P54YbbmDmzJn07NmTwsJCUlJSnC6r3in060hxeSV/nv0l730bmHZ33FEJPHJlFtnHNXa4MhER2dfSpUsZPHgwa9eu5b777uOOO+7A642MadEK/TqQs3YXVzzz+d7vB2a34KErTnGwIhEROZCKigoGDBiA3+9n4cKFdO/e3emSQkqhfwT8fsucnA3c/p+v9j434XftGNE9tLstiYjIoW3fvp20tDSio6N59dVXadmyJWlpaU6XFXLhM2qhgVm+fjet73z7V4G/6I7eCnwRkQbmvffeo2PHjkycOBGATp06RWTgg0L/sJRW+Ljsqc/2fp/ZKI7Fd/amWaM4B6sSEZF9VVRUcPvtt9OvXz8aN27MlVde6XRJjlP3/mG4Zc6Xex+//sfuZLUIn72URUQiwZo1axg8eDCLFy/m2muv5dFHHyUhIcHpshyn0K+l619cxtxvtgDwt8s6KvBFRBqg3bt3s2bNGubMmaMW/j7UvV8LY1/J3Rv47Y5OYWB2C4crEhGRKkVFRfzrX/8CoHPnzqxZs0aBvx+Ffg3d/v9W8MqyjQD8uXcb3v7z2Xg8xuGqREQEYMWKFWRnZzNs2DC++SawIqq6839LoV8D/83dzOylG4BA4I/pc6LDFYmICASW0n3qqafo2rUre/bs4b333qN9+/ZOl9Vg6Z5+NW79dy5zcgIt/MFdWyjwRUQakBEjRjBjxgzOP/98pk2bRkZGhtMlNWgK/UMorfDtDXyAey/u4GA1IiKyv759+5KVlcVf/vKXsNowxykK/UMYNf2X3fu+mtCXmCj9gxIRcZLP5+P+++/n6KOP5tprr2XIkCFOlxRWlGIH8e3mfD75cQcAd1/UjmRthysi4qiNGzfSu3dv7rnnHpYuXep0OWFJLf2DmLlkHQDtM1O4+iwtrSsi4qQ33niDkSNHUlZWxvTp0xk+fLjTJYUlhf4B5BVX8NKi9UCglS8iIs5ZuXIll1xyCZ06dWL27NmceKIGVB8uhf4BjJy2BICM5Fi6tmrscDUiIpEpLy+PRo0acfLJJ/Pqq6/Sv39/YmNjnS4rrOme/n6e//gnlq/fA8DDV2ZhjBbgEREJJWst06ZNo2XLlnz2WWBzs9///vcK/Dqg0N+HtZYnPvhx7/c9Tkx3sBoRkciTn5/PkCFDGDlyJKeeeiotW7Z0uiRXUejv46G537OnuIKEGC/f3NvP6XJERCLK0qVLOfXUU5kzZw6TJk1i/vz5NG/e3OmyXEX39IOKyip5ZuFqAG4/vy2JsfrRiIiE0nvvvUdlZSULFy6ke/fuTpfjSmrpB131/GIAjm4Ux7DT1Z0kIhIKW7du5fPPPwfgtttuIzc3V4Ffj9ScBfx+y7eb8wA464QmGrwnIhIC8+bNY/jw4cTExPDjjz8SExNDamqq02W5mlr6wNRP11DhswD8/YpTHK5GRMTdKioquP322+nXrx9HHXUUb731FjExMU6XFRHU0gde/WITENhFT618EZH6k5+fT9++fVm8eDHXXXcd//jHP7TvfQhFfEv/uy35fLM5H4Cx/do6XI2IiLslJyfToUMH5syZwz//+U8FfohFfOi/8eVmANpkJNE4Ud1LIiJ1raioiD/+8Y+sWrUKYwzPP/88V155pdNlRaSI7t73++3erv0/9W7jcDUiIu6zYsUKBg4cyPfff88pp5xCmzb6XeukiG7pT/98LT/nldIsJY4LOh7tdDkiIq5hreXJJ5+ka9eu5OXlMX/+fEaPHu10WREv5KFvjJlijPncGDPuIK+nGWPeNsbkGGP+WZ+1vPvNFgB6npSO16MBfCIideWf//wnN910E7179yY3N5devXo5XZIQ4tA3xlwGeK21ZwCtjTEH6ucZBvzLWpsNJBtjsuujlj3F5Sz6aRcA157Tuj4uISISccrKygD4wx/+wJQpU3jzzTdJT9c+Jg1FqFv6PYE5wcfzgLMOcMxOoIMxJhVoAWyoj0KeWPDLxjrHpyfVxyVERCKGz+fj3nvvpVOnThQUFBAfH8/VV1+tadANTKhDPxHYFHy8C2h6gGM+AVoCfwJWBo/7FWPMdcHu/5zt27fXuog9xeU8/8kaACZd0qHW7xcRkV9s3LiRXr16MWHCBLKz66VzVupIqEO/EIgPPk46yPXvAa631k4EvgNG7n+AtfZZa222tTb7cLqNFny3DQhM0xuqdfZFRA7b66+/TlZWFsuWLWP69Om8+OKLJCcnO12WHESoQ38Zv3TpZwFrD3BMGtDRGOMFugG2rov4bPVOAE5sqn+YIiKHy+/38/DDD9OyZUuWL1/O8OHDnS5JqhHqefqvAR8bYzKB84FBxphJ1tp9R/L/DXiBQBf/58CsuizAWrt31P6os1vV5alFRCLCd999x1FHHUV6ejr/+c9/aNSoEbGxsU6XJTUQ0pa+tTafwGC+RcC51trc/QIfa+0Sa217a22StbaPtbawLmtYvb2QgtJKUhOi6dRCuzmJiNSUtZapU6fSpUsXbrnlFgAyMjIU+GEk5PP0rbW7rbVzrLVbQn1tgMVrAuMCux7XWKNKRURqKC8vj6uuuoprrrmGbt268dBDDzldkhyGiFuRb+bi9QB0bdXY4UpERMLDN998Q+fOnXnllVeYNGkS7733HpmZmU6XJYchotbe9/nt3h31Tm99lMPViIiEh4yMDJo2bcqLL77ImWee6XQ5cgQiqqX/yY879j7u0LyRg5WIiDRsW7du5dZbb6WyspL09HQ+/fRTBb4LRFToP/DWSgCu6nasw5WIiDRc8+bN45RTTuHxxx9n+fLlABoD5RIRFfp7SsoBOENd+yIiv1FeXs6tt95Kv379SE9PZ+nSpXTt2tXpsqQORcw9fb/fsjU/sBFEj5O0+YOIyP5GjhzJzJkzGT16NJMnTyYhIcHpkqSORUzor9tVDEC015ASF+1wNSIiDYfP58Pr9fLXv/6Vyy67jMsvv9zpkqSeREzov7p8IwAnZGjpXRERgKKiIv70pz8RExPD008/TefOnencubPTZUk9iph7+vO+3QrAacelOVyJiIjzcnNzyc7O5oUXXqBx48ZYW+fbnEgDFBGhb63luy0FAFycpQUlRCRyWWt54okn6NatG3l5ecyfP5/7779fo/MjRESEftWCPACnHquWvohErk2bNnHHHXfQu3dvcnNz6dWrl9MlSQhFxD39hT9sBwKtfK9Hn2ZFJPJ8/fXXtG/fnmOOOYYlS5bQtm1bte4jUES09LcXBKbqNYrXqH0RiSyVlZVMmDCBrKwsXnrpJQBOPvlkBX6EioiW/rTP1gLQ/YQmzhYiIhJCGzZsYMiQIXz88ccMGzaMSy65xOmSxGGuD/3Cssq9jzVyX0QixVtvvcXw4cMpKytjxowZDBs2zOmSpAFwfeh/sipwP79xYgxHJcU6XI2ISOi0atWKWbNm0aZNG6dLkQbC9ff0n/pwNQCDTmvhcCUiIvVr5cqVvPDCCwBceOGFLF68WIEvv+L60I8KjtZP1tK7IuJS1lqmTJlCdnY2d911F4WFhQB4vV6HK5OGxvWhv7MosLPemcdrZz0RcZ+8vDwGDx7MqFGjOP3008nJySEpKcnpsqSBcvU9/ZJyH+uDG+2c2FRr7ouIu5SVldG1a1dWr17NAw88wK233qrWvRySq0P/6815WAutmyQSH6P/EETEHay1GGOIjY1lzJgxnHLKKZx55plOlyVhwNXd+z9sDay3n5GiUfsi4g5btmzh/PPP55133gHg+uuvV+BLjbk69FdtDQxmyWwU73AlIiJHbt68eWRlZbFw4UJ27NjhdDkShlwd+i8tWgfAxZ20s56IhK/y8nJuvfVW+vXrR3p6Ojk5OVpsRw6La0M/r6SCSn9gf+jTW2vkvoiEr9dff52HH36Y66+/nqVLl9K+fXunS5Iw5dqBfCt/DmynmxwbRVy0BvGJSPhZv349xx57LFdccQWffvqp7t3LEXNtS/+L9XsA6Nk2w+FKRERqp6ioiKuvvpr27duzZs0ajDEKfKkTrm3pl1b4APBo90gRCSNffvklgwYN4ocffuDOO++kRQstIS51x7Ut/Zx1uwDIbqmd9UQkPDzxxBN069aN/Px85s+fz6RJk4iKcm3bTBzg2tAvLg+09HU/X0TCxVdffUWfPn3Izc2lV69eTpcjLuTaj5BV9/SPa5LocCUiIge3cOFCUlJSOPXUU3n88ceJjo7GGN2XlPrh2pZ+YnDZ3WMbJzhciYjIb1VWVnLPPffQq1cvxo0bB0BMTIwCX+qVK1v6+aUVFAW79zOStQSviDQsGzZsYMiQIXz88ccMHz6cJ554wumSJEK4MvRXbMgD4LijEvSpWUQalK+//ppzzjmHiooKXnzxRYYOHep0SRJBXNm9vzW/FICMlDiHKxER+bW2bdsycOBAli9frsCXkHNl6FdN1+vYvJHDlYiIwMqVKzn//PPZsWMHUVFRPP3007Rp08bpsiQCuTL0f84LtPSjvOraFxHnWGuZMmUK2dnZLFu2jNWrVztdkkQ4V4Z+1Rz9Vkdpup6IOCMvL4/BgwczatQozjjjDHJzc+nWrZvTZUmEc2Xor9wc2GznmDRN1xMRZ4wdO5Z///vfPPDAA8ybN4+jjz7a6ZJE3Dl6Pz05loKyShrFRztdiohEEL/fT15eHmlpadx///2MHDmSM844w+myRPZyZejvKi4H4OhUjd4XkdDYsmULw4cPp7i4mA8//JD09HTS09OdLkvkV1zXvV/h87OnuAKAtIQYh6sRkUjw7rvvkpWVtXexHa9Xe35Iw+S60N+4u2TvY6/21RWRelReXs7YsWPp378/GRkZ5OTkcN1112lRMGmwXBf663cVAxCv3fVEpJ6VlZXx2muvcf3117NkyRLat2/vdEkih+S6e/olwel6jRPVtS8i9eP111+nb9++JCcns2zZMlJSUpwuSaRGXNfS/2FrAQCnHZfmcCUi4jaFhYWMHDmSSy65hCeffBJAgS9hxXUt/ar7+FW77ImI1IUvv/ySgQMHsmrVKsaPH89f/vIXp0sSqTXXhf6in3YC0K1VY4crERG3ePnllxk+fDhNmjTh/fff59xzz3W6JJHD4rru/fySwHQ9LcwjInWlc+fOXHrppeTm5irwJay5LvS3F5QBWoJXRI7MwoUL+dOf/oS1ljZt2jB79myaNGnidFkiR8R1oV81P7ZZI63GJyK1V1lZyT333EOvXr2YO3cuO3fudLokkTrjqtC31rKtILCtbrMUhb6I1M6GDRs499xzmThxIsOGDWP58uVq3YuruGog357iCip8luS4KOJjtDiPiNScz+fjvPPOY/Pmzbz00ksMGTLE6ZJE6py7Qr9Ea+6LSO2UlpYSHR2N1+vl2WefpXnz5pxwwglOlyVSL1zVvV9QGgj9lHhXfZYRkXqycuVKunbtysMPPwxAjx49FPjiaq4K/ard9RKiFfoicnDWWp5//nm6dOnCli1byMrKcrokkZAIeegbY6YYYz43xoyr5rinjDG/q825N+8J7LBXUqHV+ETkwPLy8hg8eDDXXnstZ555Jrm5uZx//vlOlyUSEiENfWPMZYDXWnsG0NoY0+Ygx50NNLPW/rc251+6djcAmakauS8iB/btt9/y2muv8cADDzBv3jyOPvpop0sSCZlQt/R7AnOCj+cBZ+1/gDEmGngOWGuM+X1tTr41PzBdLzZKI/dF5Bd+v58FCxYAcMYZZ7B27VruuOMOPB5X3eEUqVao/8UnApuCj3cBTQ9wzHDgW+DvQFdjzM37H2CMuc4Yk2OMydm+ffve56O9gYV5srXDnogE/fzzz/Tt25fevXuzbNkyAJo1a+ZwVSLOCHXoFwLxwcdJB7n+qcCz1totwEvAbxa6ttY+a63NttZmp6en733+iw17AGjVJLGOyxaRcDR37lyysrL47LPPeO655+jcubPTJYk4KtShv4xfuvSzgLUHOOZHoHXwcTawrqYnrxq9nxynzXZEIt24ceM4//zzadasGTk5OYwaNWrvMt0ikeqIQ98Y4wkOvKuJ14BhxpjJwADgG2PMpP2OmQKca4z5CLgReKSmtTRJCizK0zQltqZvERGXatGiBb5qINkAACAASURBVDfeeCOLFy+mXbt2Tpcj0iBUO6HdGBMD/BV4EIiz1pYEn48DBhIYmPcuUO22dtbafGNMT6AP8PdgF37ufscUAFfW7q8RUFrhByApVvP0RSLRzJkz8Xq9DBw4kNGjRztdjkiDU5OWvgcYC9wM3L3P8y8BdwIGqKjpBa21u621c4KBX2estXvn58dFa/S+SCQpLCxkxIgRDBkyhOnTp2OtdbokkQapJk3icqAIeBvIMcZ8DrQhMP2ui7W22Bjj+Go4xeU+fH5LfLSXaK+m4YhEii+++IJBgwaxatUqxo8fz91336179yIHUW3oW2v9xpgKa+2PxpgxwHrgC2AJ8HtjzJxDnyE0dhWVA5Corn2RiPHTTz9x+umnk56ezoIFC+jZs6fTJYk0aLVNyC3W2i+NMacCjwHtgM/rvqza21ZQBsCOwjKHKxGR+lZZWUlUVBStW7fm//7v/7jiiiu0771IDdS4H9wY0xX4f8aY/gSm0v0EbLXWLiVwX99RVTvsZTbSErwibvbhhx9y4okn8sUXXwBw/fXXK/BFauiQoW+MOd0Y83rw2y+AhwlMu9tFYIR9WnD6XbwxZnLwz6PGmGfqteoDKA0O4js+IynUlxaREKisrOTuu++mV69eREdHawldkcNQXfd+awJL50YDrwITgD8TmEtvgXzgeAIfHloF3+MFQt7czi+pBCA9SXP0Rdxm/fr1DBkyhE8++YQRI0bw+OOPk5SkD/gitXXI0LfWzgRmGmM2Egj4hwiEfW/gdQJz868BVllrL63nWg9pe/Befkq8VuMTcZsXXniB3NxcXnrpJYYMGeJ0OSJhq6b9Y+XW2quA3UAjoBS4AkgBWhL4IOCodTuLAIjyOD68QETqQElJCd9++y0Ad955JytWrFDgixyh2t4UewY4GdhJoOs/21q7rM6rOgwJMYFOi+go3ecTCXfffvst3bp1o2/fvpSUlBAdHc1xxx3ndFkiYa/ahDSBVS5ijTGNgdkE7u8nEpiyl1G/5dVcQWngnn6ro7TDnki4stby7LPPkp2dzdatW3n++eeJj4+v/o0iUiM1macfS+DefX9glrX2awBjzHBghjHmTCCm/kqsmS827AZ0T18kXJWUlPCHP/yBV155hfPOO48XX3xR+96L1LGa9IVXAjcRaOXfXvWktfYd4FHAT+CDgaPSEgKfO7y6py8SlmJjYykrK+PBBx/k3XffVeCL1IOaLMNbCfwr+G3Rfq/9Ldj936UeaquVLzfsAaBZihbnEQkXfr+fyZMnM2DAAI499lhee+01rZsvUo+OeNSbDVhRF8UcCZ8/MIEgKU5r74uEg59//pm+ffsyduxYpk+fDqDAF6lnNQp9Y0ysMeY/xpjY4PdNjDEZxphEY4zPGJO4z7EzjDHd66vg6qQnO36nQUSq8c4775CVlcVnn33Gc889x7hx45wuSSQiVLcMb9XHbj/w++BXgKnAu0AFgXX3y4LHpwCDgMz6KPZgyiv9ex8nxnhDeWkRqaXZs2dzwQUX0KxZM3Jychg1apRa+CIhUl1L/3VjzMXW2goAa22FMeZaAiP5/2qtLQ88bSuDxw8nsIDPa/VW8QEUlQUunxjj1S8PkQbK2sAtuAsvvJC7776bxYsX065dO4erEoksBw19Y4yHwCY7s4LT8zDGtAD+F7jVWrtgv+PjgL8A91R9SAiVwmDoF5X7QnlZEamhl156ibPOOouSkhKSk5O59957Nf9exAEHDX1rrd9aew+B3fSGBZ9+DFhsrX30AG/5G/Az8GydV1mN3cXlAJygHfZEGpTCwkJGjBjBsGHD8Hg8FBQUOF2SSESryZS9t4G3jTF+4DagEAL3+22gv84YY/4XuAQ43VrrP/jZ6keFL3DJTbtLQn1pETmIL774gkGDBvHjjz9y9913M378eKKiNLtGxEmH/C/QGDMXKA5+a4EHAU9wFP8eY0zX4Gu/A86w1m6tt0oPIT+4BG/nlqlOXF5E9mOt5cYbb6SoqIgFCxbQo0cPp0sSEapv6S8nODKfQEv+ZOBlAsvubgY+A/4POAa42xjz51DfzwfYVRjo3i+tCHkng4jsY8eOHURFRZGamsrMmTNJTk6mSZMmTpclIkGHHL1vrb3TWnsvgcF7ENhKNyn4/BPW2scJ9AB0Ak4DnqvXag8ivzTwOSNB0/VEHPPBBx9wyimncNNNNwHQqlUrBb5IA1OTXfb+BswnEO5nA0OMMTfte4y19gcC8/jPN8ZcXB+FHkpxcNR+slbjEwm5yspKxo8fT+/evUlJSeF//ud/nC5JRA6iusV5bgFGAX8GsNb+BAwB/maMaV11WPC1zQTu+d9Tb9UetM7A10baYU8kpDZs2ECPHj2YNGkSI0aMYNmyZXTq1MnpskTkIKpr6X8NXAQsgcDc/eD8/DeBRw5w/HSggzGmQ51WWY0ftxYCkJGszXZEQsnj8bBlyxZmzpzJ1KlTSUxMrP5NIuKY6u7pz7PWLiYwcM8QuKcPgRb9xcaYkyCwNn/w+F0EFvS5tN4qPoDY6MC9/ILSymqOFJEjVVJSwmOPPYbf76d58+Z89913DB482OmyRKQGarrLniUwSt8PYK3NBU4H1gELCXbxB80C3q/DGqsvLri8Z6t0tTJE6tM333xD165d+fOf/8yHH34IQHS0bquJhIsahb61ttxaO8Zam7/PcznW2lJr7bnW2tJ9nv8/a+1n9VHswewpDoze12Y7IvXDWsuzzz7LaaedxrZt25g7dy69evVyuiwRqaWatvQbtA27A+sHaa8dkfoxZswYRo8eTffu3cnNzaVfv35OlyQih6HaOW7GmCjgaGvthhocezzwoLX2yroorqYykmP5BvB6XPEZRqTBufLKKzn66KMZO3YsHv13JhK2ajKx/RTgEyCh6gljTDPgbeDMfbv2gSQC2+6GVHlw7f3GCTGhvrSIK/l8Ph566CHy8/N58MEH6d69O927d3e6LBE5QjX5yF4K7L+0bgWQBZTv93z5AY6td19vCgw1iIlSC0TkSG3evJm+ffty1113sW7dOvx+LW8t4hY1SUlf8M++KiGw/e5+zzvy26FZSmB+vu7pixyZt99+m6ysLD7//HOef/55Zs6cqe58ERdxxbq1/uCUPa3IJ3L4tm3bxhVXXEGbNm2YPXs2J598stMliUgdc0Xol1UGOhhi1b0vUmtbt26ladOmZGRkMHfuXLp27UpcnFa3FHGjmqZkI2PMT1V/gFzA7Ptc8Pn59VfqwRWVBVbii4vWPH2R2njppZc44YQTmDVrFgDnnHOOAl/ExWra0i8F7q3BcZnA2MMv5/AUlQdCPynWFR0XIvWuoKCAm266iRkzZnD22Wdz1llnOV2SiIRATVOyzFo7vbqDgmvxhzz0y9W9L1Jjy5cvZ9CgQaxevZoJEyZw1113ERWlD8wikSDs/0u3gN+Cx0CUV6EvUp3Vq1dTUlLCBx98wDnnnON0OSISQrUOfWPMKOBsfjuND6DREVdUS1Wb7fhtqK8sEj62b9/OokWL+N3vfseVV17JBRdcoG1wRSJQTULf8OsBfwlAY4Jz9feTVBdF1YZV2Isc0gcffMCQIUMoKipi3bp1pKamKvBFIlRNQj8u+AcAa+1jwGMHOtAYczIQ0h32qjL/qEQtwSuyr8rKSiZMmMADDzzAiSeeyNtvv01qaqrTZYmIg6oNfWvtl+wT+tWIAeKPqKJaqurej/JqOT6RKhUVFfTq1YtPPvmEq6++mscee0ytexGpm611jTGnGGO8wFdA07o4Z01Vde9HaalQkb2io6Pp378/M2fOZMqUKQp8EQFqEPrGmG7GmIMeFwz7L4B0wAscXXflVa9qAJ9a+hLpSkpKuPHGG/nwww8BuOuuuxg8eLCzRYlIg1KT5vEsDtG9b631ERjsVwYMBeYHPwiESCD11+0sDt0lRRqYb775hq5du/L000+zePFip8sRkQaqJgP5yoEyY8yE4PcH2knPEpjC9xfg38EPAiFR1dLv1EIDlCTyWGt57rnn+Mtf/kJycjJz586lX79+TpclIg1UTUK/KuT/DKwAzgIWAacDq/hlvn5H4HigVx3XeEiVfq3GJ5HrjTfeYPTo0fTp04cZM2bQrFkzp0sSkQasNklpgb4EuvIvC36dDEwMPr4EeNlau7OuizyUqjv5a3cWhfKyIo4qKCgA4He/+x2zZ89m7ty5CnwRqdbhNI8tv0yP3/e5Z4D/PeKKaqmqez/rGHXvi/v5fD7uv/9+jj/+eNavX4/H42HgwIF4NHtFRGrgoN37wRH7zxFYfe8cAiPz9758gLdst9bm12151fMFU1/b6orbbd68maFDh/LBBx8wePBgGjUK+arXIhLmDnVPP5rAVrlJwNsEFt5pcHzWYoCSipCNHRQJubfeeosRI0ZQXFzM1KlTGTFiBMZomqqI1M5B+wSttWXW2vOB9QSCP6+ac7U1xlxZl8XVhCf4i8+rX4DiYrNnzyYzM5Nly5YxcuRIBb6IHJaa7rJnD/J1X32AEcArR1hTrVQtw5uZGtLVf0Xq3apVq/D7/Zx00kk8/fTTREVFERdX0xWxRUR+q6ajf0zwz+Lg1/nB5+8CHgw+fg6IMcacX6cVVqNqGd7oKLV8xD1efPFFOnfuzPXXXw9AUlKSAl9EjlhtWvqTgo+n7feaITBqvxT4B3At8M7BTmSMmQK0A96y1k46xHFNgbnW2lMPVZjfWrxAjFejlyX8FRQU8Mc//pEXX3yRc845hxkzZjhdkoi4SE1CPwaIs9YecDqeCdxc/F8Co/tnAPcYY6KttRUHOPYywGutPcMYM9UY08Zau+og132EGuzY57eBCyfE1PTzi0jDtGbNGvr27ctPP/3EhAkTGDduHF6vZqWISN2pSVI+yS+r7h1IHIHWfqy1dosxpteBAj+oJzAn+HgegdX9fhP6xpheQBGwpQb1ARCtDXckzGVmZnLyySczZcoUzjnnHKfLEREXqrZP3Fr7D2tt2SFeLwFaAVuD339xiNMlApuCj3dxgG14jTExwHjg9oOdxBhznTEmxxiTU1xcAvwyil8knGzfvp3Ro0eTl5dHbGwsb7zxhgJfROpNndwIt9aus1XD6A+tkF+67JMOcv3bgaestXsOcb1nrbXZ1trs+PjA4CavR6Ev4WXBggVkZWUxbdo0Fi1a5HQ5IhIBQj36bRmBLn2ALGDtAY45D/ijMeZDoJMx5vlDnbDqk4ZHoS9horKykrvuuovzzjuPlJQUlixZop3xRCQkQj367TXgY2NMJnA+MMgYM8laO67qAGvt3r5NY8yH1tpRNTmxMl/Cxa233so//vEPrr76ah577DESExOdLklEIkRIQ99am2+M6UlgIZ+/W2u3ALmHOL5n9ecMfNWKfNLQlZeXExMTw1//+le6devGwIEDnS5JRCJMyCe3W2t3W2vnBAO/zqh7Xxqq4uJiRo8ezUUXXYTf76d58+YKfBFxRNivaFO10Y5G70tD9PXXX9O1a1eeffZZOnfujN/vd7okEYlgYb+iTWxU4HPLnuJyhysR+YW1ln/+85+MGTOGRo0aMW/ePPr06eN0WSIS4cK+pV+lWSOtSy4NR2FhIQ888AA9evQgNzdXgS8iDULYt/Q1kE8akmXLltGxY0eSk5P59NNPad68OR6Paz5bi0iYc81vIw3kEyf5fD7uv/9+unXrxsMPPwxAixYtFPgi0qCEf0s/uDyPWvrilM2bNzN06FA++OADBg8ezM033+x0SSIiBxT2oV+1JJ+W4RUnLFiwgIEDB1JcXMzUqVMZMWIERh9ARaSBCvvQ1zK84qT09HROOOEEXnjhBdq2bet0OSIihxT2NxwrfIF5z1EKfQmRH374gb/97W8AdOzYkc8++0yBLyJhIexDv2r0frlPi55I/ZsxYwadO3fmkUceYfPmzQDqzheRsBH2oV91Lz8lLuzvVEgDVlBQwLBhw/jDH/5Aly5dyM3NJTMz0+myRERqxTVJGaWpUVJPrLX06tWL5cuXM2HCBMaNG4fX63W6LBGRWgv70K8ayKfR+1LX/H4/xhiMMYwfP57U1FTOOeec6t8oItJAhX/zOJj6UV6FvtSdbdu2cdFFF/HEE08AcPHFFyvwRSTshX3oa3EeqWvvv/8+WVlZLFiwgJiYGKfLERGpMy4I/QB178uRqqio4M4776RPnz6kpaWxZMkSRo8e7XRZIiJ1JuxDv7yyap5+2P9VxGE5OTk8+OCDXHPNNSxdupRTTjnF6ZJEROpU2A/kq1qUR737crhWrlzJySefzBlnnEFubi4dO3Z0uiQRkXrhmuZxbLRr/ioSIsXFxYwePZoOHTqwePFiAAW+iLha2Lf0q1bki1b3vtTC119/zaBBg/jmm2+47bbb6Ny5s9MliYjUu/AP/eBXTdmTmnr++ee5+eabadSoEfPmzaNPnz5OlyQiEhJh3zz2B5v60d6w/6tIiOTl5dGjRw9yc3MV+CISUVyTlNplTw7l008/Ze7cuQCMGTOGt99+m6ZNmzpclYhIaLkn9NXSlwPw+XxMmjSJHj16MH78eKy1eDwePBoDIiIRyBW/+aJ1P18OYNOmTZx33nmMHz+eAQMG8P7772sbXBGJaGE/kA+0Gp/81qZNm8jKyqKkpIQXXniBP/zhDwp8EYl47gh9/TKXIGstxhgyMzO56aabGDRoEG3btnW6LBGRBsEV3ftq6QvADz/8wDnnnMPKlSsxxjBhwgQFvojIPlwR+hrEF9mstUyfPp3OnTvz7bffsnnzZqdLEhFpkFyRlh5170esgoIChg0bxogRI8jOzmbFihX07t3b6bJERBokV4T+jsIyp0sQh/zjH/9g1qxZTJw4kffff5/mzZs7XZKISIPlioF8zVPjnS5BQsjv97NlyxYyMzO57bbb6N+/P127dnW6LBGRBs8VLX0N5Isc27Zt46KLLqJ79+4UFhYSGxurwBcRqSFXtPQV+pHh/fffZ+jQoezevZvJkyeTmJjodEkiImHFFS19Zb67VVZWcuedd9KnTx/S0tJYsmQJN954oxbbERGpJVeEvlr67maM4bPPPmPUqFEsXbqUU045xemSRETCkiu69zVlz53+85//cOaZZ9KsWTPmzp1LXFyc0yWJiIQ1tfSlwSkuLua6667j8ssv5+GHHwZQ4IuI1AG19KVB+eqrrxg0aBArV67k9ttvZ+LEiU6XJCLiGq4IfYt1ugSpA3PnzuXSSy+lUaNGvPvuu/Tp08fpkkREXMUV3fs/bS9yugSpA127dmXQoEHk5uYq8EVE6oErQr99ZorTJchh+uSTT7jiiisoLy+ncePGvPDCCzRt2tTpskREXMkVoW/QPf1w4/P5uO++++jRowdffvklmzZtcrokERHXc0foK/PDyqZNmzjvvPO4++67GTRoEMuXL6dVq1ZOlyUi4nquGMin0A8vgwcPZvny5UybNo3hw4drZT0RkRBxRehryl7DV1ZWhs/nIyEhgWeeeQav18tJJ53kdFkiIhHFFd37Cv2G7fvvv+f000/n5ptvBqBdu3YKfBERB7gi9JX5DZO1lmnTptGlSxc2bNjApZde6nRJIiIRzSWhr9RvaPLz8xk6dCgjR47ktNNOIzc3l4suusjpskREIpo7Qt/pAuQ3du7cydy5c7nvvvuYP38+zZs3d7okEZGI55KBfE5XIAB+v5/XXnuNSy+9lFatWrF69WpSU1OdLktERILc0dJX977jtm3bxoUXXsjll1/OW2+9BaDAFxFpYNTSlyM2f/58hg0bxu7du3nqqae48MILnS5JREQOwBUtfd3Vd87f//53+vbtS1paGkuXLuWGG25Qz4uISAPlitBXS985p556KqNGjSInJ4eOHTs6XY6IiByCK7r31bAMrTlz5rBu3TrGjh1Lnz59tA2uiEiYcElLX6kfCkVFRVx77bUMHDiQ119/ncrKSqdLEhGRWgh56BtjphhjPjfGjDvI642MMe8YY+YZY141xsRUd87tBWV1X6j8yooVK8jOzmbKlCnccccdfPDBB0RFuaKjSEQkYoQ09I0xlwFea+0ZQGtjTJsDHDYEmGyt7QtsAfpXd974GG/dFiq/snv3bs466yz27NnDe++9xwMPPEB0dLTTZYmISC2FuqnWE5gTfDwPOAtYte8B1tqn9vk2Hdi2/0mMMdcB1wHENDuBoxKr7QyQw1BSUkJ8fDxpaWlMnz6d7t27k5GR4XRZIiJymELdvZ8IbAo+3gU0PdiBxpgzgDRr7aL9X7PWPmutzbbWZoPu6deHTz75hJNOOonXX38dgEsvvVSBLyIS5kId+oVAfPBx0sGub4xpDDwOXF2Tk2peeN3x+XxMnDiRHj16EBMTozXzRURcJNShv4xAlz5AFrB2/wOCA/deAe6w1q6ryUk1T79ubNy4kd69e3PPPfcwePBgli9fTnZ2ttNliYhIHQl16L8GDDPGTAYGAN8YYybtd8w1QGfgLmPMh8aYgdWdVN37dWPBggXk5OQwffp0XnrpJVJSUpwuSURE6pCx1ob2gsakAX2Aj6y1W470fLFHt7G3PPn/+Ntlpxx5cRGorKyM5cuXc8YZZ2Ct5eeffyYzM9PpskRE5BCMMcuqxrXVRsjn6Vtrd1tr59RF4FfRPf3D8/3333P66afTp08ftm/fjjFGgS8i4mIuWZHP6QrCi7WWadOm0aVLFzZs2MDs2bNJT093uiwREalnLgl9pX5N+Xw+hg0bxsiRIznttNPIzc3loosucrosEREJAYV+hPF6vWRkZHDfffcxf/58TckTEYkgrlg8XZl/aH6/n8mTJ3P22WfTrVs3Jk+e7HRJIiLiAFe09HcXlTtdQoO1detWLrjgAsaOHcusWbOcLkdERBzkipZ+bJQ23DmQefPmMXz4cPLy8nj66acZPXq00yWJiIiDXBH6qQna8W1/77//Pv369aNdu3bMnz+fDh06OF2SiIg4zBXd+/ILn88HQM+ePXnkkUdYunSpAl9ERAC3hL4G8gHw8ssv065dO7Zs2YLX6+Wvf/0rCQkJTpclIiINhCtC30R46hcVFTFq1CgGDRpE48aNqaiocLokERFpgNwR+hGc+StWrCA7O5upU6dy55138tFHH9GiRQunyxIRkQbIFQP5ItkDDzxAXl4e7733Hr1793a6HBERacBcEfqR1tDftWsXRUVFtGjRgqeeegqfz6e180VEpFrq3g8zH3/8MZ06deKqq67CWkvjxo0V+CIiUiPuCP0IaOv7fD4mTpxIz549iY2N5dFHH9WWwiIiUivu6N53efZt27aNAQMGsHDhQoYOHcpTTz1FcnKy02WJiEiYcUXou11iYiLFxcVMnz6d4cOHO12OiIiEKZd077tPaWkpkyZNoqioiMTERBYtWqTAFxGRI+KK0Hdb//53333H6aefzvjx43nzzTcB8Hjc8X+ViIg4xxVJ4pbIt9YydepUunTpwqZNm3jzzTcZOHCg02WJiIhLuCL03WLSpElcc801dOvWjdzcXC688EKnSxIRERdxxUC+cO/dt9ZijGHIkCHExMTwP//zP3i9XqfLEhERl3FFSz9c5+n7/X4efvhhBgwYgLWW1q1bc9tttynwRUSkXrgj9MMw87du3coFF1zArbfeit/vp7S01OmSRETE5VwR+uFm3rx5ZGVlsXDhQp555hn+/e9/Ex8f73RZIiLicu64p+90AbVQXFzMiBEjOOqoo5g/fz4dOnRwuiQREYkQ7gj9MEj9DRs2kJmZSUJCAu+++y7HH388CQkJTpclIiIRxBXd+w1945mXX36ZDh068NBDDwHQsWNHBb6IiIScK0K/oSoqKmLUqFEMGjSI9u3bc9VVVzldkoiIRDCFfj356quvyM7OZurUqdx5550sXLiQ4447zumyREQkgumefj0pKSmhuLiY+fPn06tXL6fLERERcUdLv6EszrNz506mTp0KQNeuXVm1apUCX0REGgx3hH4DyPyPPvqITp06ccMNN7B27VoAYmJinC1KRERkH64IfSdVVlYyYcIEzj33XOLj4/n88891715ERBokd9zTd+i61louvvhi3nnnHYYNG8aTTz5JcnKyQ9WIiIgcmjtC36HUN8Zw1VVXMXjwYIYNG+ZMESIiIjXkjtAPYVu/tLSUsWPH0rlzZ0aOHMnQoUNDdm0REZEjoXv6tbBy5Uq6devGE088wY8//uh0OSIiIrXijpZ+PTf0rbW88MIL3HzzzSQkJPDWW29xwQUX1O9FRURE6pgrWvo+v63X8+fk5HDNNdfQrVs3cnNzFfgiIhKWXNHS31NSUS/n3b59O+np6Zx22mnMnTuX8847D6/XWy/XEhERqW+uaOkf3SiuTs/n9/v5+9//znHHHcfSpUsB6NevnwJfRETCmita+nV5S3/r1q0MHz6cefPmcfnll3PCCSfU4dlFRESc44qWfl2N5Js3bx5ZWVl89NFHPPPMM7zyyiukpaXVyblFRESc5oqWvqeOmvqff/45TZo04f3336d9+/Z1c1IREZEGwhUt/SNZnOenn37i008/BWDcuHEsXbpUgS8iIq7kitA/3Jb+rFmz6NSpE6NGjcLn8+H1eomPj6/b4kRERBoIV4R+bW/pFxUVcfXVV3PVVVfRsWNH5s6dq5H5IiLieq64p1+b7v3t27dz9tln88MPPzBu3DjuueceoqJc8WMQERE5JFekXW1a+k2aNOHcc8/l6aef5txzz62/okRERBoYl3TvHzr1d+7cyZAhQ/jpp58wxijwRUQkIrki9A81kG/hwoVkZWXxyiuv7F1dT0REJBK5IvQP1NCvrKxkwoQJ9OrVi4SEBBYtWsTAgQNDX5yIiEgD4Y7QP8BAvsmTJ3PvvfcydOhQli1bRufOnR2oTEREpOFw3UC+wsJCkpKS+OMf/8jxxx/P5Zdf7lxhIiIiDYg7WvrGUFpayk03gocPjwAACcRJREFU3UTXrl0pKioiMTFRgS8iIrKPkIe+MWaKMeZzY8y4IzlmX5vWrKJbt248+eST9O/fX/PuRUREDiCkoW+MuQzwWmvPAFobY9oczjH78hXnM2bw+WzevJm33nqLyZMnExsbWz9/ARERkTAW6pZ+T2BO8PE84KzDPGYvf0kebU/pQm5uLhdccEEdlSkiIuI+oe4HTwQ2BR/vAg40pL7aY4wx1wHXBb8ty13yydfNmzev41JlP02AHU4X4XL6Gdc//Yzrn37GoXHS4bwp1KFfCFRtY5fEgXsaqj3GWvss8CyAMSbHWptd96XKvvRzrn/6Gdc//Yzrn37GoWGMyTmc94W6e38Zv3TXZwFrD/MYERERqaVQt/RfAz42xmQC5wODjDGTrLXjDnHM6SGuUURExJVC2tK31uYTGKi3CDjXWpu7X+Af6Ji8ak77bD2UKr+ln3P908+4/ulnXP/0Mw6Nw/o5G2ttXRciIiIiDZArVuQTERGR6oVN6NfHSn7ya9X9/IwxjYwx7xhj5hljXjXGxIS6Rjeo6b9TY8z/b+/ug6Wu6jiOvz9crqBFQprgNCg1ND5SwBT40MNFJVDHxNHGISzQaQzHUNSZEmZIa6bsaZhIpBFLq8nMssLuhBqUJD1gYUWRNOYUDoH2NJEiCCHf/jhnLz+2e+/+Fu5d2r2f18yOd3+/s2ePx3W/+zvnd75npKRfN6pdraSOPl4m6aJGtauVlPi+GCFppaT1ku5sdPtaRf4eWNvL+XZJnZJ+KumqWvU1RdDvj0x+dqCS/TcLWBwR7wSeA6Y3so2toM7P6WfZv3zVSirbx5LeBoyKiM6GNrAFlOzj9wL35uV7wyR5GV+dJI0AvkLKX9OTecATEXE2cJmkYb3V2RRBn37I5Gf/o4Ma/RcRyyJiVX76GuBvjWlaS+mgxOdU0jnAi6QfV1afDmr0saR24C5gs6SLG9e0ltFB7c/xP4HTJQ0HRgNbGtO0lvIycDnwfC9lOtj/3+IxoNcfV80S9Kuz9I08yDLWs9L9J+lMYERErGtEw1pMzX7O0yaLgJsb2K5WUuaz/D7gSeDTwCRJ8xrUtlZRpo9/ApwIXAdsyuWsDhHxfIkVbHXFvmYJ+n2Syc96Var/JL0auB2oOXdk3SrTzzcDyyJie8Na1VrK9PEEYHlEPAd8DZjSoLa1ijJ9fAswNyI+BvwBuLJBbRto6op9zRIYncmv/9Xsv3wF+i1gQUQ807imtZQyn9PzgGslrQHGS/piY5rWMsr08dPA6/Pfbwb8ea5PmT4eAYyT1AZMBrw+vH/UFfuaYp2+pFcBa4EfkjP5Ae8uJvbppswZJYZFLCvZx9cAnwA25ENfiIj7G93WZlamn6vKr4mIjsa1sPmV/CwPA+4mDYW2A5dFxNZuqrNulOzjScA9pCH+nwOXRMSOw9Dcplf5Hsj3+pwaEUsL504EVgKrgbNIse/lHutqhqAPXXcxTgUey0NyB1XGeub+awz3c/9zH/c/9/H/j5y2/q3AI7Uudpsm6JuZmdmhaZY5fTMzMztEDvpmZmYDhIO+mfU7SW2SdLjbYTbQOeibtQhJMySd1cO5of25V4KkaZJuKjy/TdIjhSIfATrz8q0y9c3KSaDMrA8NPtwNMLM+swj4kaTFpHXRFQuAMcBMSUFK4HFtRNwJIGkC8BK111G3AUOB30XEnqpz/wYWSjouIj4M7AZ25fovAD4EvKd6KVFOhzsY2B0R+wqnrgJ2AhcVyrYBRwD7ImJ3jbaaWTcc9M1agKQTgHHAu4BJwJSIWCPpy6SAOheYm8uuIWXxqlhHCtLFoHsEKcAXc34PysdPIiezkTQEEPAL4EJgSTcbftwIXBMRlZ0ZB0XES/nc5cBSYJekSiBvJ/0A2Stpc6GeduAo0kZEHy/VMWZ2AAd9s9Ywm7TT1tZ8NV9L1xV3RAypPilpDnBrRIypUc+ngOurjnX9UCi05VxJ9+S/HwRm5L/vy/98OCL+kV9zHzA8lxkP/DIi9uWd3C4kpYE2s4PgOX2zJidpMPB+0tV6xaM54M4GhkpaLekFSdtJSTx626qzHrcCxwDtESFgLPAs8BQpuJ8CfI80vTCINHows/D6I4EzgKckTZX0ADCKlLd9IfBj4Py8T/h64Phch5kdBF/pmzW/K0nz9EVTImJN5YmkJaTh+93RTUYuSdcDOyPirnreuLgpUE4R+vX8eIG0qc0O0g+MjcBNEbG86vU7gA9KWg7sAS4ljRSsIv0guCQivp/vO5gdESvqaZ+ZHchX+mZNLM/lfxJY1sP5oZKOI20lOxOYLWmOpNOrik4F3l51bJCk4YXHsZKO7+Y93pSH5DuB2yLiRtLc/5CI+Euu+xbgDkmduT3VXgS2k+5LOId0n8AVwGslTSTtzT7Wy/7MDo2Dvllz20YKqE9UHa8M7+8CRgOfAWaR5skXA2+oKr+Xwjx/Nhr4V+Hxd+ChYgFJbwF+RbrBbnxELCm0a7uktkgWkzZmOYGq7x1J5wOPA+eSRgUeJN29/21gGmljnDGkVQgPSDqqVqeYWfcc9M2aWETsLe64VTAlz7EfSQrKK4GlETGDNIy+vkT1z0SEKg/S3fPVeQA2AqdFxMUR8ceqc5MorAiIiNX5WNfKAUkLga+SRiI2kXZjGwZ8nrQMcDJwGjCRtAXuG0l3/JvZQfCcvlmLykPhleHw1cB0Sb8lzd1vqbe+iNhLGhEoegh4Ry+j7vt6OCdJg4BvAN+MiKfzwcmk/cC/BPwpIubnLVq3RMSzksYDkUcQetw+1My656Bv1poeLfz9OuA7pKx4AdzRh+9zQa6zK7mOpJOA3wBbgc6IuKFSOK/TrywRHEealtgjqTrZzytIPxjmFF4L+3MFTCPd2W9mdXDQN2tNleQ87cDeiAhJPyDNlY/qqzeJiJ3F53lf73tJQ/YfBX6WRxwWRMSunMlvT37tBnr4DpK0AtgcEfP7qq1m5jl9s1bRxv7/n9srByPiP8ArJS0CpgMbgLsljcyb4IyXdAppyd/Rkk6WdDJpPXx75Xl+nJrLj61+c0nHSLqBdIW/CbguIrYBZ5Lm4jdKmifp6P7rAjOrxVf6Zq1hKPuT1nRl2Msb8DxMuiN+Iuku/M8BT5JuinucA/Pur6uqt/p5e67v0lz/fNJSwAnA74EPRMR3K4XzPHwHcDUpkc9iSfdHxBU1/n2KP2LMrI+omzwdZtZCJI2MiL9WHTu2kvb2EOs+GzgPWJGH63srO4S0ZHBbRKytUXYV8OeIuPpQ22hm+znom5mZDRAePjMzMxsgHPTNzMwGCAd9MzOzAcJB38zMbIBw0DczMxsgHPTNzMwGiP8CbIlE7sQiSxQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_roc_curve(fpr, tpr, label=None):\n",
    "    plt.plot(fpr, tpr, linewidth=2, label=label)\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "    plt.xlabel('假正类率', fontsize=16)\n",
    "    plt.ylabel('真正类率', fontsize=16)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_roc_curve(fpr, tpr)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9577288593844492"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算曲线下面积AUC，虚线是随机分类0.5到1\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "roc_auc_score(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 召回率TPR越高，分类器的假正类FPR就越多\n",
    "* 虚线表示纯随机分类器的ROC曲线，好的分类器应该远离这条线，向左上角\n",
    "* 是使用精度/召回率 PR曲线，还是使用ROC，关键在于 正类非常少或者更关注假正类而不是假负类，选择PR，反之ROC\n",
    "* 例如：前面例子ROC曲线很不错是因为跟负类 非5 相比， 正类 数据5 数量真的很少"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练随机森林分类器，比较SGD分类器的ROC曲线和ROC AUC分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 获取训练集中每个实例的分数\n",
    "* RandomForestClassifier 没有descision_function(),但是拥有dict_proda()方法，sklearn中分类器都有这两个中的一个\n",
    "* dict_proda返回一个矩阵，每行一个实例，每列代表一个类别的概率，比如这个图片 70%是5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "forest_clf = RandomForestClassifier(n_estimators=10, random_state=42)\n",
    "y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3,\n",
    "                                    method=\"predict_proba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1. , 0. ],\n",
       "       [1. , 0. ],\n",
       "       [1. , 0. ],\n",
       "       ...,\n",
       "       [1. , 0. ],\n",
       "       [0.6, 0.4],\n",
       "       [1. , 0. ]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_probas_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 绘制ROC曲线，需要决策值不是概率，直接使用正类的概率作为决策值：\n",
    "y_scores_forest = y_probas_forest[:, 1] \n",
    "fpr_forest, tpr_forest, thresholds_forest = roc_curve(y_train_5,y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0. , 0. , ..., 0. , 0.4, 0. ])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(fpr, tpr, \"b:\", linewidth=2, label=\"SGD\")\n",
    "plot_roc_curve(fpr_forest, tpr_forest, \"Random Forest\")\n",
    "plt.legend(loc=\"lower right\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9920927546425455"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rand 比SGD 好很多，ROC AUC的分数也高很多\n",
    "roc_auc_score(y_train_5, y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9832007073386384"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 再看一下 精度和召回率 也很高\n",
    "y_train_pred_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3)\n",
    "precision_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8205128205128205"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 选择合适的指标利用交叉验证来对分类器进行评估\n",
    "* 选择满足需求的精度/召回率权衡\n",
    "* 使用ROC曲线和ROC AUC分数比较多个模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多类别分类器\n",
    "* 尝试5 之外的检测\n",
    "* 多类别分类器 区分两个以上的类别\n",
    "* 随机森里和朴素贝叶斯可以直接处理多个类别\n",
    "* 支持向量机svm和线性分类器只可以处理二元分类器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 解决方案\n",
    "1. 将数字图片分类0到9，训练10个二元分类器，每个数字一个，检测一张图片时，获取每个分类器的决策分数，哪个最高属于哪个，称为一对多OvA\n",
    "2. 为每一对数字训练一个二元分类器，区分0，1 区分0，2 区分1，2 称为一对一OvO策略，存在N个类别，需要N*（N-1）/2个分类器，最后看哪个类别获胜最多\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 优缺点\n",
    "* OvO 只需要用到部分训练集对其必须区分两个类别进行训练\n",
    "* 对于较小训练集合OvO比较有优势， 大训练集合 OvA 速度快，所以OvA更常用，比如svm 在数据规模扩大时表现糟糕\n",
    "* sklearn 检查到使用二元分类算法进行多类别分类任务，会自动运行OvA，SVM分类器除外"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_clf.fit(X_train, y_train)\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-147203.53005403, -569176.26634331, -605551.56063717,\n",
       "        -173124.6316745 , -437532.19067095,   38178.80435509,\n",
       "        -823695.73099554, -250159.2759811 , -652124.97126243,\n",
       "        -450631.78785551]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 内部实际上训练了10个二元分类器，获得图片的决策分数，然后选择了分数最高的类别\n",
    "# 返回10个分数，每个类别1个\n",
    "some_digit_scores = sgd_clf.decision_function([some_digit])\n",
    "some_digit_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(some_digit_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 目标类别列表会存储在classes_这个属性中，按值大小排列，\n",
    "sgd_clf.classes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_clf.classes_[np.argmax(some_digit_scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用OvO策略，一对一或者一对多\n",
    "from sklearn.multiclass import OneVsOneClassifier\n",
    "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter=5, tol=-np.infty, random_state=42))\n",
    "ovo_clf.fit(X_train, y_train)\n",
    "ovo_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ovo_clf.estimators_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用随机森林\n",
    "forest_clf.fit(X_train, y_train)\n",
    "forest_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0., 1., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机森林直接将实例分为多个类别，调用predict_proba()可以获得分类器将每个实例分类为每个类别的概率列表\n",
    "forest_clf.predict_proba([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 评估分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.86072785, 0.84494225, 0.83372506])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用交叉验证评估SGD的准确率\n",
    "cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.9120176 , 0.90629531, 0.91183678])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将输入进行简单缩放 ，可以得到准确率 90 %以上\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()  # 标准缩放\n",
    "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n",
    "cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 错误分析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 项目流程\n",
    "1. 探索数据准备的选项\n",
    "2. 尝试多个模型\n",
    "3. 选择最佳模型并用GridSearchCV对参数进行微调\n",
    "4. 尽可能自动化\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 确定了一个相对合适的模型，进一步优化，分析其错误类型\n",
    "* 查看混淆矩阵\n",
    "* 使用cross_val_predict()进行预测\n",
    "* 调用confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python相关软件安装目录\\python安装目录\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[5739,    4,   24,   10,   11,   40,   44,   10,   37,    4],\n",
       "       [   1, 6487,   40,   29,    6,   42,    9,   13,  105,   10],\n",
       "       [  54,   39, 5337,   97,   84,   22,   95,   58,  156,   16],\n",
       "       [  53,   37,  133, 5349,    3,  238,   33,   57,  138,   90],\n",
       "       [  17,   27,   33,   11, 5358,    9,   55,   31,   86,  215],\n",
       "       [  76,   40,   32,  176,   85, 4606,  108,   31,  176,   91],\n",
       "       [  29,   26,   51,    2,   51,   95, 5616,    5,   43,    0],\n",
       "       [  26,   17,   66,   34,   54,    8,    4, 5819,   16,  221],\n",
       "       [  51,  153,   67,  155,   12,  156,   60,   29, 5022,  146],\n",
       "       [  44,   28,   27,   87,  159,   32,    2,  220,   80, 5270]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)\n",
    "conf_mx = confusion_matrix(y_train, y_train_pred)\n",
    "conf_mx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 理想情况下：矩阵对角线的值最大，其余应该都为0\n",
    "\n",
    "# 使用matplotlib的matshow 函数来查看混淆矩阵的图像表示\n",
    "plt.matshow(conf_mx, cmap = plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 看起来不错，大多数图片都在主对角线上，说明它们被正确分类\n",
    "# 数字5 看起来比较暗，说明：1. 数字5图片较少  2. 分类器在数字5上执行效果不如其他数字上好\n",
    "# 假设把焦点放在错误上，为取得错误率，而不是错误绝对值，需要将混淆矩阵中每个值除以相应类别中的图片数量\n",
    "\n",
    "row_sums = conf_mx.sum(axis=1, keepdims=True)\n",
    "norm_conf_mx = conf_mx / row_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 用0填充对角线 只保留错误，重新绘制\n",
    "np.fill_diagonal(norm_conf_mx, 0)\n",
    "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 每行代表实际类别，每列代表预测类别\n",
    "# 8，9列比较亮，说明许多图片被错误的分类为数字8，9\n",
    "# 类别8，9行也偏亮，说明数字8和9经常会跟其他数字混淆\n",
    "# 有些很暗，比如行1，大多数数字1都被正确的分类，一些和8混淆\n",
    "# 5和3是错误最多的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 结论\n",
    "* 改进数字8和9的分类\n",
    "* 修正数字3和5的混淆\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何优化分类器\n",
    "* 尝试多收集这些数字的训练集\n",
    "* 开发一些新特征来改进分类器\n",
    "* 优化分类器算法\n",
    "* 使用pillow或opencv对图片预处理，让显示模型更突出\n",
    "* 分析单个错误"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAccAAAHBCAYAAAAcpXCvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydd1hUx9fHv0sULIC9xd47lhgbQazBLmKLFU2MosQYDSoxGnuBRCzYu2iMUUwEXruiBsWGqKjYFVAEUTpIlXn/uL857i67sMDehZj5PA+PuPfuzuHuvTNzuoIxBoFAIBAIBB8wKmwBBAKBQCAoaojFUSAQCAQCNcTiKBAIBAKBGmJxFAgEAoFADbE4CgQCgUCghlgcBQKBQCBQo1gux0Weh0CQHUVhC5BPxPMsEGRH4/MsNEeBQCAQCNQQi6NAIBAIBGqIxVEgEAgEAjXE4igQCAQCgRpicRQIBAKBQI3colU/KubNmwcAiImJQbNmzQAAkZGRWLZsmcbz69SpgwULFmD8+PGGErFIk5iYiOHDh+PkyZPZjjHG0LBhQ8yZMwcA8M033xhavDzz999/4+uvvwYApKam4smTJwCA6tWrF6ZYAj2TmJgIAIiOjkadOnW0nvf69WsAQJUqVWSRIzMzEwAQHBwMf39/mnfWr1+PQYMGyTJmftm1axe++eYbzJo1CwAwY8YMOrZq1SooFKoBnj/++COA/F+7P/74Aw8fPgQABAUF4YsvvgAA+Pj4YODAgSrnKssiJ4pcunLoJfT77t27AIAjR44gMjJS5diGDRsAAIMHD6aLYGdnB3Nzc30MTVy+fBndu3cHAKSlpen8PnNzc9y+fRsAULt2bb3KlBNv3rzB1atXAUiT+M6dO1WOd+vWDQDg6+sruyzXr18HAPz66684fPiwxnMYY1AoFChWTNpvNW3alI5NmTIF/fr1Q40aNWSXNTcuXLiAP/74AwBw4MABxMfHAwBKlCiRl8VRpHIUcfi8dv78eXz11VcAgL59+2LXrl10TkJCAj0/3t7edG/ze0Kfchw6dAiTJ08GAMTFxcHIyAhZWVkAAFdXV1qEigpGRkbZFkAOf9aV4crGnTt38jTO//3f/wEAhg0bhvT0dJUxAGiUgT+f/fv3x8aNG/M0nhY0/qGyLI58MTxz5gy8vb1x/vx5aTANf6imi7Bs2TI4OzvnZ2itXLhwAV9++SUAICMjI0/vrV+/PgBpga1YsaJe5VLm8ePHNHFv374dL1++VDlevHhxAFB5sCZNmoR169ZpvZHzi/JDPXHiRABAcnJyjufnJEOrVq1w5swZAED58uX1KGnuREdHAwCmTp0KHx8fpKSkZDvHwsKCNkE6IBbHIszdu3fh4+MDAJg7dy5GjhwJQNJugoOD8c8//wAAdu/eTdocANqQ62txTEhIwLfffgsAePToES3SzZs3x8OHDzF79mwAwKVLl9CxY0e9jKkvRowYAU9PT3z22WcAgAoVKtCxtLQ0XLhwQeV8a2trAHnfrPNnc9q0aTh79iwA4O3btzkujvxYpUqVcPbsWbRo0SJPY2pA5DkKBAKBQKALBdIcuRocFxdH6q2XlxeePn0K4IOmocsuQPmYtbW1LObCunXrAgBCQ0PptXLlyqFHjx60wzMyMsLMmTMBZDcRnDhxgrRPfZOamooJEybgzz//1HqOk5MTAKBnz57o3bs3vR4VFaV3jfbgwYMAQLvu3MhNcwSA0aNHAwA8PDwKJlwe4bvcrl27qrxeu3ZtdOnSBQDwzz//4NKlSwCEWTUqKorMXcrMnTsXzs7OGDduHADDWwByIiEhAQCwevVq7NixAy9evAAAmJmZoXPnzgCAc+fO4ZNPPiEtZ/DgwTRvBQUF4eeffwYALFmyRC8ybd26lSxBR44cQZkyZQAAp0+fhoODA4YMGQJAMqsWNSIiIvD27Vvy0ZqZmdExX19f9OrVK9v5AFC5cuV8j3nlyhUAyGYxA1StP3zNsLS0xJEjR1S02nyi8XnOV0BOVFQUgoOD8fvvvwMAdu7cmeMCqIylpaU08P98U9zkaghu3LgBQLr4/EGoXbs21q9fT+dcuXIFYWFhGt8/fvx4krdRo0Z6lc3d3T3bwsid9M2bN8eECRMQEBBAcvDrbGdnh3LlyulVFkDyweSGpaUlHBwcAABZWVk4dOgQRowYAQBYvnw57t+/r3e58gP3f37++edIT08n3/PcuXNpE3bo0KE8+aI/Rs6dOwdAWhz47+rMmDEDa9euBQD8/vvvtPAUJkFBQXQfXr58WeVYZmYmLZxbt25F3759UalSJQCAg4MDmdJ//fVX2nzqi0mTJmHSpEn0/1OnTgEAhgwZgpo1a2LhwoV6HU+fVKtWDdWqVVN5jW8keNAdj8Hw9vbWy+Y8J9Oy8hzNqVGjhj4WRq0Is6pAIBAIBGrkS3N0cHCAl5dXrudVr14dgwYNwpQpU+g1rnEVK1YMf/zxh0E1R24GKl++PO1+uQZ78eJFAFIKgrpDvlWrVgCAvXv36l1j5FSrVg2VKlVC27ZtAQC2trZk6gWk0Gpu7k1MTMSnn34KQNJ45MDR0RGAFCzATSYZGRkoW7Ystm3bBkCKmFXWWseMGYO3b98CkEzSRUVz5Kaea9euqbweHR2NVatWAZA0Xx7y/1/k2LFjGDp0KACoBCwVK1aMwvPDw8MBACEhIQCAd+/eGVZIJY4fPw43NzcA0rObmpoKADA1NYWVlRVpktbW1mTOBKRnh5sEL1++TO4D/rfrm5s3bwKQrGt79uwBAJQpUwZubm4oVaqULGPqE25NmTx5MrlDeNoW14RzSo8pKNu2bcO9e/ewbt06eo1bKa2srGQbF8jj4sgnyevXr0PdV2liYgIAsLGxIb+cjY0NRXpyoqKiAEhmjFWrVql8Dl+o9B2pqk5ycrKKvyQuLo78TOqRrKVKlcKmTZsAQB9RUVoZM2YM+vbti7JlywKQfJ/cX7F8+XLcu3dP5Xy5FmlOp06dAADPnz+nvz8xMRFdunTJ0fzxww8/AADJrox6vlJhM3ToUFowS5QoQea2/xpPnz6Fi4sLLYodO3ak1IJixYrRBqh79+4q0Z3bt28nP37FihVVFiG5CAwMBAAMHz4cSUlJAKTJeerUqQCAcePGac21Cw8Px4gRI8i37O3tjQEDBsgqLzdPK5sFO3XqBFNTU9psFMW82oyMDFy4cIH8oWfPnkX//v0BSNfe0tJS1kWxVq1aAKTc08zMTI3uOrlzQ4VZVSAQCAQCNfKkOfKIoVevXqms5DY2Nli0aBEAKehBHW6mdHR0hL+/PwApYlT5MxQKBVWMkCsilCd59+rVSyViNSdsbW0NloOkHv3HK/NoysvkgQcHDhyg/Cm5UDaLa+PRo0cICAjQel1bt26Nfv366Vu0PBMdHU3m6vPnz6NEiRIAgJUrV6Jq1aqFKVqhcfr0aZQtWxabN28GIGn4PBgjLi6OApiUtUYA+PPPPymIzNraGidOnKBj/LrqG25BGTlyJMaOHQtA0nR5DrAm9u7dCwD47bffEBQURK+PGzeOzJ5yaUG2trYAJFMqr8Czf/9+WFlZoWbNmgCkv2Xu3Ll0niG5c+cOWQSDg4PpO0xLS8M///xDgTb79u1Du3btAAANGzaUXa5PPvkEQPZ7Tpnnz5/LqnXnKZWDCzp//nxs2LABzZs3ByBNMtysqkxISAj27NlD/j1NybXclLVr1y7Y2NgAkEyKcrBy5UoAoBtRFxo1aoTg4GBZ5dIGv6a1atXClClTyC/y4MEDMgfVrl0bN2/eROnSpWWXJyQkBImJiRTVx/08gLRhevbsmcb3ValSBdeuXTNYhZzg4GDyIa9atYrMue3atcPKlStx69YtOpenl7i5ueUlDP2jTuVQxsHBAVu2bNHpXCsrK9rIHT16tFBTPbj75pdffqHqUhkZGWjRogUt9hs3bqSI++HDhxtMtpSUFKxdu5biLU6ePElxDcePH88WJSoXmzdvxs8//4y4uLhsx3hq1vTp0wGA/LuG4tGjRwCkRXnbtm30fXLZAGDAgAHYtm1bgdJH/od+K+Ts3r2bnKQ9e/bUmKuzb98+2Nvb55jmwasitG7dmvxtcsHLoPXu3RuxsbE6v++7774DABWnsCHgE3zr1q1hamqqcowHFZw9e1aWPEdleL7nwIEDtaa55JTnWKtWLTx//lw2+eLi4ujz27Rpg+vXr9OEaGxsrPV769mzJ44ePUrn5YGPfnHkwSNff/01VWMCgCZNmtAmFgBpGrwuJqdt27Z0bQ2tkbu6uuKnn34CIFWVmjBhAgDg+++/R+PGjWmTXr16daraVBgpKdzHu2jRIlp8Ro8ejW3btlH8hZx06NCB0sPU4c8zX7RPnjxZaD75iIgIlTQ3HpioUCjw6aefUk4ulzUfiAo5AoFAIBDoQoEq5PAKOK6uruRzVIbX59OlQk6dOnXIXMcjz+Ti2bNn2TTHrVu3ApBC+vluiicI86K6/v7+ei+Inl94FY8FCxbg77//li1yKzAwkLTUnLRtXSrkcPONvq/hnTt3aGc5ceJE3L59m6wEO3fuJJ8Kh9+rc+bM0egO0IGPWnMMDAykYh3KpvMmTZrg+PHjKv45rrH36dMnm/bITf+6FJTQF4wx1K9fn+Tes2dPtmounDJlypDmy6OzCwvexWbnzp3Yu3cvxowZI/uYixYtIj8zIMU4lCxZEoBUEFxZq9y+fTt1sClseMWrgQMHZku/4tHBvAqSjmivsJ7DT4HYsWMHa9GiBWvevDlr3rw5a9GiBStevDgrXrw4UygUTKFQMEgPLP1foVCwQ4cOFXRoFhERwe7du8cePnzIHj58mKf3Ojs7M2dnZxWZFAoFe/z4cYHl0heLFy9mixcvZgqFgtnb28s2zooVK5iRkVGuPwqFItdz5syZw+bMmSOLnF26dGFdunSh+0nTj5mZGatZsyZLSEhgCQkJBRkut+emqP7oxIgRI1SuW4MGDViDBg1YaGio1ve8fPmSOTo6qrzP1NSUmZqasu3bt+s6dDZSU1NZamoqi46O1un8t2/fsgULFrDk5GSWnJys8Zw7d+6wO3fusBIlSrAHDx6wBw8e5Fs+fXHgwAF24MABVrx4cbZx48ZCk+PevXvs3r17rEWLFirPblBQUKHJpI2IiAg2Z84cVrt2bVa7dm1mZGTEzM3Nmbm5OZsyZUpePkrj8yLMqgKBQCAQqCGr1/frr7/OporzVA7lqDYAVKkEkIqXF7RihYODA7y9vSnI586dOzqH/aoXLlCWizf1LGyYkjmcF3qXAxMTEwqrfv/+fY7nWVhYUGWSadOmZWsN9erVK9nk5EnWv/zyC16+fEmR1MbGxnQvVahQAX379qWUnjZt2sgmz78RHpXNk+QBKWyfN7fmidmaqF69OmbOnEkJ+MuWLaMk/R9++IEilZWDeXRhxYoVAIDDhw/j1q1bdC9qo0KFCjnWLGWMUcpYpUqV0Lhx4zzJIxe8JvGRI0fg7u5OaVzczGkouAvp9OnTRbI4gTJVq1bFypUrKY1n9+7dVFjh8OHD6Nu3LwBQ8YI8o02lZDqYYdLS0lhaWhp7/fp1XlRYFbiJQ1mF79atW74/78aNG+zGjRvM2NhYxSRqY2PDMjIyWEZGRq6fERQUxIKCgrKZVWvXrp1vufTN/Pnz2fz585lCoWArVqyQdaxJkyaxSZMmaTSV9unTh/Xp04cdOXJE5T2azLFjx45lY8eOlVXWnLhy5QozMjJiTk5OzMnJqSAfVdjmUVnNqnZ2dqxGjRqsRo0abO/evXm8NBKtW7dWMbH26tWL9erVK8+f07t3b9a7d28GoMD3+atXr9jIkSNJpv379xfo8+TA09OTAaB5sbBwcXEpNLNqbGws/eSFW7dusXLlyrFy5coxIyMjVrlyZVa5cmV2+fLl3N6q8XkpkObItcAePXpQiH9edxs8ZFxf8J2rek7iqVOnaEecm7N2+fLlGl9X7iJemNy+fVsl76hHjx6yjrdmzRoAwLx587Id46XF1FNNNMHr8QYEBFBCsSFZs2YNsrKy/rPJ/rpy+PDhAn/GL7/8Qi2ZGGPw8/MDIKUe5eV+Vc5v8/LyomC9vAR18Zy5Hj16IDw8nLRXueqpAtIzWqpUKZ0T5nl6iaurKxo3bmyQRHtN8EA2HvDHO2/ImSqmzpIlS6gh9bRp06hFWm60atUK8+fPByC19+N1njW1wNIF4XMUCAQCgUANvfkc+W7s5MmTedIeua9ROQ1A1wa7muBjT5kyhTQeDq+G8vLlS/KHcZs+13yHDBlCxY05vLhyAZJMNZKUlEQNo/NSTeT58+eURlOiRAmtPlJ9wa8RL3eVX7gPSjk9QFeio6Pz1bvt9evXVBCAN5wdNWpUnj9HkDcGDx5MDQRWrFhB33lgYGCeNEfl6idXrlwhX9yePXtUGvCqw0tdLlu2DPv27QMAvHnzBkuWLNFoAdEXXEtt37495s+fr9NY8fHxVMXp2rVrcHV1zW+KkQo8venEiRN0HWfMmEHJ/Jr8t2/evAEgPasKhQITJ04EAINU7eENqlevXk0xFatXr0Z0dDSVnsyt4QJP8+DvLwgFynPk5Y+6d+9OwjRs2JDKs3Xt2lVrzcLk5GSMGTMGR44ckQRRKMjMwdvIFISkpCR88cUXKrUUeRWUM2fO0MMTFBSETp06UYumx48fq3yOsbExlc+yt7cvsFzKdO/enYIg1qxZk2uN1Lt37wKQas9GRkYCkIId9F3aKSQkhPI+AVDQQl7+/pUrV1JDaU7r1q0BSOYxXUvJcQd7586d4ebmRqa63OBmmZUrV+L48eP0uoODA1avXg2gQPU/P+o8R33BJ6quXbvSayYmJnnaHPHuLuobmlatWuGXX34BIJVca9++PQApOO3evXv03IeFhdEcNHPmTDg4OORYh7Wg8Lq9R44cQURERI6Vbq5evQpAyuvmG3I7OzscOnRIL6Uq+Weo5x/zebZXr14qtbA9PDxornv37h1KlSpFFYQMUV+aB/w5OjrS/MNl5xvjkiVL4rfffgMgNTt+9+4dYmJiAEj5tLwcoEKhIFOwl5dXbvKLCjkCgUAgEOhCgTRHrslYWVmRQ1l5l1KmTBm0bt2amlIq90MMDg7G4sWLVarn8N2TvsyXe/bsobqKyowZM4a0tFGjRiEhIUHj+4sVK4Yvv/ySavfpGzc3N6oKVKpUKdjZ2WHBggUAsqeTBAUFUWjyq1evKPAoNDQ0r3VBc2X16tUkFwDaaZcsWRK2tra0q9O0A+c7TVtb22ypHNyszZum5oUmTZrg1atX1C9S2aSm3OHA09MT169fh6+vLwCoVMdxcnKCi4uLPnblQnPUAZ5eM23aNHrtp59+0hrwpgmuZS5evJjSOvLC7NmzaQ5o0qRJnt+fV3jawMWLF/H06VOtroBr166hd+/eAKTKUzy9ZNasWXrTbOfMmQMApGmpw5j2qlbGxsbYsGFDoVTFCQ0NJWuDplrOfM2oVKkS0tLSVKrkKB8bPHgwAKhUAdKCfguPK/PPP/+QINoqvAM5l49bunQp+Sj02f2CT6Z5KRrOI7QWLVqkc6RUfkhPT8fkyZMBfIja/fTTTwFI5kB+HY4cOQI/Pz9qeQN8yP/iD4A+ad26NRUb1wQvtaXss+APGve5KEcZcgqyOAJSN/Lt27cDgEoxbE0om2M2bNgAQK+dF8TimAu+vr5U0jApKYk2cHv27MlXizXGGB48eECl/7hJksNN5N26dUPNmjUp35ZHUxsKHx8fAFJpszZt2pDp99NPP6Xyep6enjh27Bi5Fry8vNCyZUsAmufI/MJzyd3c3GizyDevgObFkecHOzk5yTr35YYuXTlyWk8mT55MTdp1QJhVBQKBQCDQBb1ojgDINOno6AhPT08AoEjMnFZ63gx08+bNsrRE4bunkydPkuairIYPHz48W39Hngenhz5hucKd0NOmTcPvv/9Osmna1fHrM3v2bMyYMQOAPD0mV6xYkeeIvpxMNBye55jvihX4EASWlJREMvIC8RxbW1tqhGtnZ5fvsXJAaI5a4MXpR4wYgdOnT9Pr3KWSk0XiY4DPeVOmTKEoaUCa+/g8aG5ujuHDh5O50xANjtPS0gCo9tQ9f/48bty4QUFuderUQalSpQDolrdsKLS1rLK1tYWXlxcFClpYWNA5EydOzMvfIJ9ZVR2uEh89ehTe3t4UtaY8eVavXh0///wzmRUFUtTd7t27AQCHDh1SOWZtbU2mYW6CERQaYnHUAjdd800MIBXm+PvvvwEADRo0kFsEgSCvGG5xFAg+csTiKBB8PAifo0AgEAgEuiAWR4FAIBAI1BCLo0AgEAgEaojFUSAQCAQCNcTiKBAIBAKBGmJxFAgEAoFADbE4CgQCgUCghlgcBQKBQCBQQ2/NjgWCwuL27dtU4Nnb2xuWlpbU8UDOxrYCgeDjxaAVchISEqje4IwZMzBw4ECqtykQ5BVedX/ZsmV49eoVAKmjSlJSErXLGjVqFDWy1lcrNHyEFXLi4uKo5u2lS5c0nlO3bl1ERERQK6pvvvlGBhH1w/379wFI9Xx54+Pnz5/j5cuXePr0KQDovdWbrqSkpGD69Ono0qULAODzzz+nTkAFaMCdZ8LDw+Hk5ETN5bOyslCvXj0AUhlAZ2dng9R91QVejjAxMZHq806fPh3FixfXx/coKuQIBAKBQKALsmqOaWlp8PX1paLDp06dUmleaWJigmPHjgGQ+rAZilevXlH/RAA4ffo0evXqBUDqVcgbbQqy8+TJE+piolwcfcGCBVi4cKFBZRk2bBgAqUcd7ye6fv16hIaGUg/HgwcPonv37gCAbdu2qTRJLgAfneY4a9Ys0rYGDhyIoUOHAgD8/f0REhICQNK8UlJSqHlsVFQUKlasKLPIeePAgQM4ePAgjh49CuBDlwyOjY0NNS8vVqxwvErx8fEYNmyYStcS3uTckM/QzJkzsXr1aq3H+/XrhwMHDgAo/C4dvOnC9OnT6blnjCE8PJye/enTp+dXizRc4fG7d+8CAL799luVpqQ5tTVycXHBlClTAMj/RfTv3x/Hjx/XeMzY2Jgalvbs2VPvY1+5coWanpqbm9MXy+HHGjdurPexC0p8fDzatm2L58+fZztmYmKCP/74g1qQGYKlS5cCkDZhS5Ys0XjOxYsXaaIfPnx4nppe58BHtzjOmzePOtDziVoT7969g5WVFQCgYcOGNHkWBrwd3dq1a6lN3tWrV1GzZk0y+ZYoUYL8zj/88AMWL16MkiVLFo7ASkRERFDDcnd3d9q0vX79Wnb5Ll68CACYMGECnjx5glmzZgGQ5kXe4Dg0NBQA8OLFCwCgxsyFza5du9CxY0cA0uZGeZ708vLCgAED8vOxGp9nvW+dQkJCKBiC+4E4pUuXpgXn0aNHePLkCTIzMwFIPQr5F7F8+XJZFkjuU+FdsTWRlpZG/c0ePXqEKlWq6FUGS0tL6mKvUCiy+Rh4f8dPPvlE62c0bNiQdk+GDDjJyspC8eLFMWnSJADAkCFDaFLaunUr7O3tce7cOQBA27ZtZZdHl7/9iy++QIcOHQAAly9fRnx8fJHxoxQlnJ2dVXr9aaNEiRKwsbEBANy6dUtusbQSExODMWPGAABOnDhB1p5jx46hY8eOCAwMBCD1VeRt8X799ddCkVUT1apVo7kP+NBj9tatW+jUqZOsY0dHRwMAzMzM8NNPP9Em08PDg44VVSZMmEC/80Wes2XLlvwujhoRPkeBQCAQCNTQu+aYmZlJKvirV69QtmxZilCtX7++SqPe06dPkxofGRlJUXA9e/bEwIED9SrXmTNnKOKJd8UGpA7l3AzMSUpKAvBBi9Mn/fr1I7MtY4yiKjk8WuzZs2daPyMoKAgJCQkADKs5litXDn5+fqhUqRK9dvv2bfq9WLFihRYBmBMODg4ApGv/6tUroTlqwNTUNFdrTUJCAlauXImVK1cCAEU5Gor09HSaS9auXYvXr18DkPylLi4udJ6vry9pQ7NmzcLIkSMNKmduxMTEwNHRkawuADBt2jQAQPv27WUff9CgQSr/KsvFrWspKSno0aMHqlatKrs8eeH9+/c4deoUAJBFgD/PEydO1OtYel8cGzRoQIvQ/v37MWrUKK3hyZaWlvjiiy8AAJ6ensjF/1kgPvvsM+pSHh4eThO8nZ0dmSg5NWvWBCD50fTNunXr8PjxYwDAgwcP6PUHDx6gQoUKdK1SU1NV3rd582bMnz+f/q+8QBmSnMYdMmQIWrRoYUBpdKNUqVL0+5o1a7Bly5ZClObfy82bN+Hm5oapU6cCAPlyDcWXX35JMQwDBgygYD5lH52vry8mT56M/fv3A5DSJIoCKSkp5O9etWoV3rx5Q8fat2+PVatWAcjZnSI3jDFKrduwYYOKCbOocOfOHfTr10/lNVdXVwDQe7yDMKsKBAKBQKCGLLHMXPv5+uuvtZ5z9+5dzJ8/X6UIQPny5QFI2qe+KVeuHJlkAJD2NnPmzGzn8p1xhQoV9C5HnTp1yCzw22+/0W4yMjJSJfLK1NSUAnd++uknbN26lY6NGTNG5W8pTC5cuAAAqFKlioqMhUlSUhKZxgEpwIvDLRUC3bh69Spp2gcPHsT79+9Jeztw4ABpj4ZIi1izZg09I+oRnX/88QcAYPTo0diwYUOha4yPHz9GbGwspb0cO3aMzMAcHtg2YMAAihQuDLh5fPbs2TTnlCtXrtDkUefx48cUfMWjaAEpoGjLli3o27evPAMzxnL60SuBgYFs3LhxbNy4caxatWpMoVDQT8WKFZm/vz/z9/fX97DZuHTpEqtRowarUaMGMzIyUvmZMmUKy8jIYBkZGbLLkZ6ezkJCQlhISAjLzMxkjDGWlZXFsrKy2L1799jIkSPZyJEjGQBmYmLCvL29mbe3N0tJSZFdNl3466+/WMmSJVnJkiVZ1apVC1scxhhj0dHRrH379ir3lvKPn5+fPobJ7bkpqj868+zZM/bs2TPWqFEj1rhxY9a4cWPWrVs35uPjwyZMmMAmTJjAADBHR0fm6OjI0tLS8vLxemXv3r30/W7ZsoVlZWUVmixPnz5lT58+ZWXKlGGNGjVikHpwmq0AACAASURBVNJnsv1MmzbNYPOMNpKTk9n+/ftp7lMoFGzGjBlsxowZLDY2ttDkUmb+/PmscuXK9P0CYKVLl2alS5dm3t7e+hpG4/MizKoCgUAgEKghSxEAnr/z5MkTbN68mZzjiYmJKpGiysTGxsoeRcirT2zfvh0REREqx3juFnfyFwZ3797Fb7/9BgDYs2cPFUwYOnQonJycDBLJlhuJiYm4fPkyACkKlFdPcXV1hZOTUyFKJrF+/Xp8//33Wo/XrFkT27ZtAyBFRRsZ5Wt/+NEVAcgP165dI7MhYwyLFi1CrVq19DlEjnh4eACQzJO80stXX32Fe/fuUUT49evX8e7dOwBAu3btVN5vZ2dHOYX6SrznVYbat2+PzMzMbIF1nI4dO1JUv42NDcaPHw/AsFV7pk6dSvWJASkPnZvJra2tMWTIEJibmxtEljdv3tBzW6VKFfz5558ApJxM5XxQxhjKli0LQIpY5tkOBcRwFXLevn0LAKhcubLqh+VQIcfW1ha7du0CANkWSV5Z4fr161rPmTp1KlUIKV++fH4nzzwTFRWFhg0bUooG8KEwMk8QVoZHtRk6um3mzJlYs2ZNttfVw+kLi4iICHz//ffkw+H+Y87OnTvJP/XDDz+Q36du3bp5GUYsjmrY2Njg0aNHlGgvdyTr06dPyX9sampKhR5Onz6NqKgoSkHQFF3N/dHPnz+n9507d06vlWnCwsJgb29PkfvAh8IY/N68ceMGAEmZ4BGYCxYsMJi/tFWrVggKCkKTJk0ASHEPvOpQcnIyatasSRteR0dHWeeaV69e4aeffgIA7N27V+t5ymtIxYoVceHCBTRt2rSgwxtucYyLiwMAdO7cGffv36duCKampvSHRUdH0y6LwzWj48ePU3COPtFlcVS++C9evMCnn36qdzm08c033+gcaMMfoJYtW2LcuHGwsLAAIL8j/cmTJ6R57d69m0LSFQoF7O3tqXVUnTp1ZJWjIHBLxtixY9GwYUMA0j2XhwVSLI4a+O6776imrZ+fnyzBT7yjRp8+fSioDviwEe/Rowd+/PFH0mBzWhwPHz5MecLVq1enhUxfnTHev39PG34AsLe3B/BhceTHmjdvTuf06tULXl5eBqnv/Pr1a8TGxqJRo0YApMWRl68MCwvD5s2bceXKFQDAyJEj4e7uDkCeQEU+JiBttMLDwwFI1imuKQLSmuLv7w8A8PHxwZUrVyioswC58aIrh0AgEAgEuiBrV46kpCScP38ePXr0AKBq109KSkJwcDAVCL579y5pbEeOHNF7hRxlduzYQTvQ8+fPw9LSkpJw1U2/mzZtokoMchMfH0+74YiICHh7e2s9l+9+eeFnXlln+vTpOfrc9A1P1zlw4ABSUlKooMLy5ctlScnRJ56enli2bBkAKUn7xIkTAHTSeoXmqIGsrCxMnz4dgGTe5ClL+vJDZmRk4LPPPgMgJYPzoh5fffUV9UbMq1bj5+cHAOjSpQt9Hvd3FQZz587FunXrqFoY90UWBunp6eTXXbp0KVXzOnToEF3vwuTx48do3LgxqlevDgA4evQoWdDyiObnWVsYK5MhlSPHWFqAwnW9vLwMNm5qairLyspiCQkJLCEhgXXq1EkltcPExIS5u7szd3d3g8mkCzzlIz09nbm7u7PatWuz2rVrMwDM3t6e2dvbGzTlw9fXVyVlYty4cQYbuyA8f/6cPX/+nCkUCubj48N8fHx0eVthp2TInspRUFq1akVpW/pK87h//z7d2wcPHmRxcXEsLi6uQJ8ZHBzMgoODGQA2aNAgNmjQIL3Iml+Sk5PZxIkTWb169Vi9evUoxauwefLkCWvXrh1r164dMzc3ZxcuXChskdjVq1dV5px+/frl96NEKodAIBAIBDqhbdVkOuw0x44dy8aOHcsqVapUYO0KhaQ5qpOQkMCsra2ZtbU1aY880V1PCeSyEBMTw2JiYpijoyMlGhtSe0tNTWUTJ06k77B69eokU1Hm5cuX7OXLl8zU1JRZWloyS0tLlpqamtvbClsDlF1zvH//Prt//35e3qLCP//8w8qWLcvKli1b5Kwuyihrjg4ODszBwaGwRWKDBw+mZzggIKCwxSFSU1NZamoq69ChA6tbty5LT09n6enpBpeDjzto0CBZNccCJdXwFIO3b9+S7yY9PV1jSTZNxMXFFYnwf2XMzMzw999/AwCaNWuGqKgoys1U7yqub6Kioignq0SJEnmqiM+jVF1cXCiay8PDA3v27NG/oBowMTHBunXrcO/ePQBSU2e5r5c+4NGMVlZWuHTpEgDJl1EUC6gbkoCAAACgMP+8YmVlRTlou3btwldffQVACr8vKsTHx1OqT5MmTQza4UYbhw4domcIQH59aLLAGzFs374dLVu2xLfffgtAilo3FO/fv6fvST0mg/uM9UWBFkf2v2AexhgiIyMBSMngvN2So6NjthyUly9fApCaIv/444+4du0aHeOBL3IG4+gCX2jU6x1u2rQJ3bt3l23cb7/9lr7wcuXKoXPnzvS6tbW1SkizNkxMTHQ6Tw6ePn2KmzdvApDC00uXLm2QcQMCAqhjiYODA1q2bEkBSjnx7Nkzuv9OnDiBbt26AcB/fmFU5tChQ9m61uSVR48eURPdorA48qbOtra2lE52/fp1CuzIL2FhYVRchOdP6kJcXBz27dsHAJgxYwYyMzMp0K0wu3Roo0GDBmjcuDE964bE2dmZgic5gwcPBiC6cggEAoFAIDsF0hx5sqxy6sPr16+xceNGAFKlA/Uk+tjYWACSCVH5vZMnT8batWsLIo7e4GHUvNIP58svv5R13I4dO1JptsTERBw9ehSAFKJcqVIl0myaN29OKTDGxsa4d+8eVRVasmQJzp07ByB7uSw5ef/+PY4ePUrlstq2bZtr81x9UaxYMUpWPnnyJD799FMVLcDOzg6AZOHgJnNA6uv56tUrAFJVplmzZhlE3n8TY8aMoabf3DSqC3FxcZRmNGjQIJWOM4VFWFgYTp48iSVLlgCQipL4+voC+NDDtSAcOnSITH5OTk5wdnZWsZ5w9wxP/ufdTc6fP09lGAEpPYoXU5CjQhdP9I+NjaXCKLkRHByMixcvApDmx4cPHxqsw83jx49pTVmzZg2tGWZmZhg/fjx9n3ovdafNGcl0cOBHRESwiIgIVqZMGZWq6do6IqgfK1OmDNu2bRvbtm1bfh2pemfTpk3MxMSEmZiYUECOubk5Mzc3Z5cvXzaYHFeuXGELFixgCxYsYD179mTm5uZaK/yr//BAiNOnTxtM3oSEBNa8eXP6bp2cnAw2NmOMhYWFsbCwsGzdXnL7MTMzY2ZmZmzx4sV5Ga6wA2tkD8jhqU3z58+ngDQnJyedg3TmzZtH77tz505ehi4Q0dHR7OXLl5SWM378eNa6dWvWunVreobatGnD2rRpw8LCwvQ6dkBAALOxsWE2NjYMACtRogSzsLBgFhYWrHjx4vTDn1M+rwCg+zAhIYG9f/9er3KpM3jwYDZ48GDm5uaW7didO3fYnTt3mL+/P1u8eDHJb2RkpDLHNGzYkDqQyIl6V4527dqx5s2bs+bNm7Nhw4bpaxiRyiEQCAQCgS7opULOwYMHyYGcnJystbh4qVKlqJals7MzbGxsCiV4xMXFJVtdV46Hh4eK/KVKlaKagoVZreLFixcU9HTgwAEkJycDADnyORYWFli6dCkAyBo8xOH1KBcuXIh//vmHKpj4+vrCzMxM9vHViY+PR0ZGBhYvXgzgg4lcmWnTpgGQ6lhaWVkByHOx+/9MhZy4uDhqyO3q6opKlSpRNDpjjAJs0tLSULFiRTIZHjt2jLrgODs760N2rF27lu43GxsbqsDDg30AyWSo3FRYoVDQfditWzcMHToUo0aNAiCPyZJH8P/www8ICwvDmTNnAABVq1ZFTEwMAGlO6dChAzXhPnHiBBUe53Wo5YRHwIaGhsLS0hJBQUEAJNcId3tp6p7EZevSpQuWLl0qW8cOT09Pcnf8/fffCAgIwNixYwFIQTfcFFy8eHF9FYuXt/D44cOHAUitlv7v//6PXh8zZgyFAH///fdo2bKlrh8pG+vXr8fPP/8MACod4wHV8nFmZmZwd3enL0YgwW9ce3t7/PPPPwCkNJfly5eTXyqPXS7+bfxnFkdlnjx5gnv37tGzrvyseHt7q3SUOXjwoN47c0RHR2P27NkApAlUeTxOx44dUbduXQwaNAiAFB3Ly1camqysLDg6OgKQIs49PT0BSIt0r169CkUmADh79iwAYMqUKSrF25UxNzdHjx49aEEcMmQIpfXI3VbLy8uL1pAlS5bgzp076NmzJwBoVbwKiCg8LhAIBAKBLshaeLwow00x27dvx8mTJ1WO8cbHjo6OBou4/Dfx6NEjAFKiN29Z5e3tjZ49e+qt3U8R5z+pOQoEHymG6+coEHzkiMVRIPh4EGZVgUAgEAh0QSyOAoFAIBCoIRZHgUAgEAjUEIujQCAQCARqiMVRIBAIBAI1xOIoEAgEAoEaYnEUCAQCgUANsTgKBAKBQKCGWBwFAoFAIFBD3gqyAoHgX429vT08PDwAAP369cPQoUPRuXNnAKoNgo2NjfHJJ58YTK7Xr19j4sSJAKDS6AAAGjdujIMHDwL40IHC0KxatQpr1qyhhsAmJiYYMmQIAGDAgAGFItO/GV7Jbe3atVi2bBkA6XtWb2TBu3Q4Ojqifv36BRrzP1M+bu/evdSBw9vbO1s9VX4d1Ku+9+/fH97e3oYR8l9CcHAwAGDz5s00CfE2QSNHjgQA1KlTB1OmTAGgny7ruhIaGopTp07RhOnj46Py3bZo0QK2trYAQG2t8sF/pnzcihUrqLt9VlaW1vMmTJiArVu3yt6x4dmzZwCAL774AhEREQCkLhHly5enc+Lj46kd1e7duzF8+HBZZdKElZUVXr16hUaNGgEArl69iri4OADSpL5mzRrqNGHITcW/jfT0dLi5ucHLywsAcOXKFZ3eV7ZsWdy5cwcAUKNGjdxOF+XjBAKBQCDQhXxpjiEhIdi1axeWLFmS44cr93tTfg0AWrRogUmTJtHrvAGtvggMDMSGDRtw48YNAFIT1PT09BxlBbJrjubm5qQ58sa4chEREUHdQooXL47GjRsDkProRURE4M8//wQApKSkUFNZLvusWbMAAMuXL5d9916lShUAoI4c2ihXrhwAwM3NDWPHjpWluSyH95W0sbHJ9j2rf7fGxsYAgB07dlDj2zzyn9EcgQ9mS25tuX79OgBJS09NTQUgNUX29fVFt27d9CGnVl6+fAkAGDhwIF68eAEA2LBhg4p2ePHiRerBGhkZib179wKA3vtL5sTVq1ehUCjQvn17AFITZN5gffz48bh//z7++usvAMDgwYMNJlduvHv3DgCwcuVKPH78GAcOHKBjderUAQCcOXOmwCbL3NixYwcAYO7cuYiKilI5xhuT29nZoUWLFirHFi1aBABISEjAnDlzAEh/Sy7oryvH8ePH0b9/f61vat68OQDphqhSpQo9TID2RWj8+PFwd3cHIHXKzi+88/aIESPIjMHh5gvlNlQzZ85EgwYNaAHkCxCnbdu2pNJ/+umn+ZZLG5cvXwYgTTw7duygRsLGxsbo1KkTACAgIABJSUlaG30qb0IiIyNRqVIlvcupTLVq1QBApeN6bly5coUmCjngfpxjx44BAPr27QtA+s74PXf69GmEhYXRe7755hts3bo1P8P9pxbHnDh+/DgA6Xo7OTnh119/1fcQGklNTaVu9XyyVMbX1xcA0LNnTzJfHj9+vEiYMFNSUlCqVClq7xYREYGyZcsWslTA0qVLcejQIQAgk2Tv3r0BSJuSu3fvApAaH/Pz5ODatWu0vqhvwPv06YNVq1YBAJo2bapy7NWrV7T2xMXFYebMmQBA5+eAMKsKBAKBQKAL+bK/tWvXjnbommjSpAkASUWvWLEiAgMD6Rjfxd+/fx8LFy6kIJldu3Zh7ty5AFAglf3x48cApJ1DyZIl8cMPP9Axc3NzAMDs2bOzvY+b15S1s86dO+Pbb7/Vu8YYEBAAAFi4cCHOnj0LQHI8K2uA6enpuHDhgsr7TExMAEg75fj4eACg3TM/JqfpknP48GEAgIODAwVIcHOMNu7fvy+r5rh06VIA0ve/d+9etG3bFoBkLQgPDwfwwfRau3ZtAMDGjRtlk+e/QExMDJmxihcvjn79+hls7BIlSuTYWJubzoEP1qS4uDhUqFBBdtlyg89RvXr1AgCYmZkVmiyRkZGkHd65c4eCV3777TdMmjQJ79+/ByBZZrjFbfLkybLKVLlyZSQmJqq8xufu5cuXZ9MYY2NjAUguFXVrYUHI1+JYqVIl2NjY6Hy+pnNr1aoFd3d3Whytra1RsWLF/IijAp/4+vfvj9KlS9OkqQ6fMI8ePYoVK1aoHOMP1rfffotx48YVWCZlXrx4odVkoA43EVSsWBFTp06lG7dMmTIq5g4AWL9+PQAY5OHnofxBQUFkz+cbG03UrVsXY8aMkVWmVq1aAQAePHig8npERASZ1R4/fozKlSvjyJEjACC7b/ZjIzExEX5+fsjIyAAALFu2jFwm9vb26Nq1ayFKpwr35+XiNjIob9++BSAtNKVLl8b8+fMBFF60amRkJPr06YOgoCAAwI8//ki+288//xwJCQn0/4sXL2LQoEEAQM+TXNSpU4f8xGPHjkWDBg2wf/9+AEDLli3J18xNv+fPnwcAMvsCQJs2bSh1Jr8YfHa4ffs2AGDLli0IDQ2FtbU1gA8+goLCfU38X2UyMzMBSBrDnj17AAC3bt0C8GH31qFDBwpu4Ts7fVKsWDGVXa0y5cqVIw12woQJaNCgAYAPu6YnT56QXHxRBABbW1uMGDFC77LqQvXq1TW+rlAoKIz96NGjBp8Atm/fDkCawENDQwEAVatWhbe3d6Hlvv0bSUpKgrOzMwDJYhAZGalyvGPHjgBA5xgSvkjv3LmTFkPuU+abJOX7kOfAGRKueV28eBE//fQTyejh4UEWqfDwcFStWhWAYRbKhIQEAJI/MSgoCNOnTwcgpe3wDWNycjIGDRpE1qsvv/wy1wBMfcKDpxITE7FkyRJSYPz9/UmrjImJyfY+Hizo4eGRLVgnrwifo0AgEAgEahhEc+Sml7dv32L8+PH0u6mpKWbMmGEIEfDgwQMyPW7atCnbcR599eWXX8oqR7Vq1UhLHjlyJLp06QIAGDRoEP2uTkxMDDZu3Ihffvkl2zFbW1vaNRclxo0bp5JuYkg8PDwoNSg9PZ2+0xUrVqBNmzaFItO/lUuXLmHDhg1aj/NdvCF83crs2LGDrD8XL17M8VyuKZ0/f16jRUkO3r17hxs3bpA5cPPmzSrH1d01XAMfP348Jk6cKKsGyb+zoKAgzJgxg6I6ixUrRv7Q4cOH4/bt2+jQoQMAKR2rWbNmssmkTFpaGhYuXAgAcHd3R3JyMp4/f67Te3l8iz7iRGRdHOPi4jB9+nTKj3rz5o1KnuOvv/6aJ99lQThw4IDGRXH8+PFYvXo1mS4NATeXKqe4qJOamkoTvJ+fHx49eqQSLMTNDjt37pRR0tzhuU/GxsYq+YWF6c8zNzcn03V6ejpdN7lzsz5G1BeeKlWqUOWjrKwsqjLk7OyMHTt2UG6rXPDJ29HRkYLRtKU4cbgp2NbWFgsXLszRP14Q3r9/T3PM6tWr8ezZM5KtbNmylM9oZWWl4o4ICAiguWDq1KkIDAykEmn6iMNQh5sejx49il69etGz6ufnR+6ZyMhI9O/fH2vXrgUgxQ0YinPnzumSm0jPOHeXZWVlkdtOH4ujMKsKBAKBQKCG3murvnnzhnY9t2/fpvB5+kClIgADBw4ks6o2k2JB2bdvHwBg0qRJtNNUxsLCAubm5iTXzz//TLuOSpUqkaNcbmJiYuDr60vFCE6cOEHVcoDs1Ya4pmtiYoKyZctSTVMnJyeULl3aIDIr8+jRI3z++edksvnkk0/w888/AwCZSAwJT9OYNm0afbetWrWCtbU1fvvtNwAF0m7/M0UAMjMzqUJO6dKlYW1tTTt2xhhFCPbs2ROWlpZkyZArqZ0H2jRr1kxjQZGyZcvC2dmZCn6npqbijz/+AAD8/vvvSE1NpWcsp0Im+WHp0qUUgVq2bFkMGzaMIiZ1tZB9/fXX2LVrF6WgrV69Wq8yqpOZmUnav7u7O6WIjR49Gnv27DG4uRwAzp49qxIRa2ZmRibdb7/9ll6fMGECjIyMcOLECQBSgQCe3nPx4kV89tlnug6pvwo5muARYTyiEsi5fJz66126dKFKNJoqXuQXrp7ziVobmuRq27YtPv/8c0qPkCNa69SpUwCkij7x8fE6VcHJ6djw4cOxbt06AJC9Uo46Fy9eVNnktGvXDoDk6ylI1aP8wPMuT548SRMUv0b8obl27Vp+P/4/szjqire3N2xtbene++677+QaCoC0GfPz8wMgfa+1atUCkHOawZkzZzB06FBaALZv345vvvlGbzIFBATQ/Ne/f3+VSly6EhoaCgsLC4qeV45Kl4Nt27ap5C1WrlwZgORrrlevXq4mazlIT0+n9BJAWhx5KU1NhISEAFA1/Xp6euYllUPexZELX65cOZqUGWNo1qyZxqTR4OBgrF69mkKFGWO0OMrR0mXevHkaQ3853FeQ282g710nt/F7enrmugA2bNgQgGrQ0N27d3HhwgWV9/Fk+6NHj6p0K5CbxMREfP755wCkyYsTFBRU4LDqgsDvsaVLl8LPz498o+PHjycNM6eEcg2IxVEDo0aNopyz27dvG3xzpgubNm3C1KlTAUiaRk7FTAqLli1b4t69ewCkwhVcC5aDtLQ0Kvnn7e1NBUoAYMaMGWT1KcxCBbnBc9abNGlCefOWlpYU+KgtdU4JUT5OIBAIBAJd0JvmyH2LzZo10znCKjk5mSqneHl5UfkpHx8fXYfVG8rVFVJSUgAAs2bNQkxMDO3igA++lO7du+ul+C4Po+aaK49kBT5oiIMGDUK5cuWyNfbkxMTEUAV6Xs2e/02GCr8GpCLq3Kz6/v172rHdvn07R7OIIZk3b55KRSR/f38AoJB1HRGaowauXbtG13HJkiXUB7Kowa0slStXzlPxfEOQnJyMli1bUkm04OBgKvQvN1lZWbh58yYAqeCDi4sLucs8PDzIKlRU6du3LxXCBz5ENivPqVrQ+DzrLd4+PwE1pUuXpnJvhY0ms9/58+cRHh5OVWuuX79OtfuUfasFwc3NDcCHJsH5uQHLly9PC2lhpXakp6fDw8ODKoIAkmkDQJFZGAGpRNaaNWsAfNgECfSDhYUF5ZE+ffpUljF4+6KsrCyDBcsZkoCAADx//hz29vYAYLCFEZByVbk//rPPPoOFhQXNfUuWLCnUpu9ciePVrjSh7+dZmFUFAoFAIFCj0Csv8x0BY6xIFQnmVK9enSLvNm3alK1Thr4oiMni1q1bKo2juTnTkIn4/v7+2LJli8HGyy8lSpQolAi8fxPh4eFwcHAAIAWK8Y4vuVGiRAnY2dkBkCrCcCuLPtM6unfvDgCIjo7Gtm3bAOQtOI5baooaPLp6ypQpMDExgZOTUyFLpNpX15AFNFJSUiiK/+bNm7h27RqysrIAfGi4nRs1atQocNZDoS6OycnJVChYoVAUuUnryZMnePDgATXLzKmijaHhEw9fGHmJLOBDXiH3F8hFeno6FfhWLwP4ySefyN4VPj/8/vvvubbX+q+Tnp5OuY2TJk2Cq6srgA+VVXQhPDyc/GZy5DxGRkZSVPv+/fspjzCn6Ox3795RyTngQ9qCHDx79gxmZmY6ReympKSQGfX+/fvYtGlToUZ3c0aPHk2/y23CDg8PJx/18ePHs/mCeTS5+vWMj49XqczFefnyJaXs5DtqmmtsWn5k49q1a6xr167MyMiIGRkZMYVCwXx8fJiPj4+cwzLGGIuNjWWhoaEsNDSUpaamMsYYS0hIYAkJCezs2bNswIABbMCAAaxp06YkH/+pU6cOq1OnDtu9e7fscmrD3d2d1a1bl9WtW5euHZevW7duLD4+nsXHx8s2vp+fH/Pz82MODg5MoVBo/Jk8ebJs4+eXCxcusPbt29O1srCwYImJiSwxMTGvH5Xbc1NUf3QiPDycmZqaMlNTUwaANWrUiDVq1IidPXuWZWRkaH3f4cOH6b6sUaMGi4uLY3FxcboOqxMBAQEsICCAmZubM0gBRkyhULAJEyawCRMmMF9fX/bmzRt6nl+8eMFcXFyYi4sLa9q0KVMoFMzY2JgZGxuzRYsW6VU2ZYYOHcpWrVqV4zkxMTEsJiaG2dnZ0d+ydu1a9u7dO9nkyo3Y2FgWGxvLVq5cyYyMjFjNmjVZzZo12f3792Udd8aMGXQNALDWrVuz1q1bs549e7Jx48axmzdvsps3b6q8JzExkVlYWKi8T/nH3d2dubu76zK8xudF+BwFAoFAIFBD7+XjcoP3DgsLC1OJfurSpQs1odVnhRxNzJ07Fy4uLgCAMWPGoHr16hTCzG3d2uCmIkMUKudNPePj4+Hn50fXS93ubmJiQmalP/74o8B9627evEnlq+bOnUufff78efj4+MDd3R3Ah4K/yvDI1HPnzhksmjAkJIRM8urRzxkZGZTkvG/fPjx8+JDur+PHj+c1hYNTtOz/uqPz8+zp6QkAGDZsmMrryt+pra0tPbOA9GzwEo3z58+nsmRyEBYWRr1gNUUw8oo53G2jDO9uI2dZwz59+uDFixdUMahNmzZkXo6NjcVvv/1GXWuSkpLIx7t48eJC6TvJ5eC9bLds2YJatWpRkQS5U8L69OlDZeCAD/fZ5MmTVQoQnD9/nkoIpqenZ/t+ixcvDkB67nmaHHeL5YC8FXJygvvH9u7di++//14a+H+TGb/Bz507p4+hcoQvNo0bN85WZ5VfB3W/Z40aNXDgkE2rVgAAIABJREFUwAEAQPPmzemLksM/Gh8fT4vzrl27qP0K72aiacwGDRpg3759es1BSk1NJWe8QqGgwJ7MzMwcg6YqV66MM2fOANCcGiMXo0aNosoe+/btQ8mSJamN18mTJ3HlyhUA0t/SsGFDqrfLy9vlg49+ceQpOcePH6cSjJcuXcr1fbz25bJly2SvkMOroezcuZPq5fJya5qe5ypVqmDs2LG0aOexKlKeOHv2LPr27Uv+MGNjY0p3488I98lv27atUDvG8BzvsWPHUlcLQKpjK3fcAufs2bNwdHQEADx8+DBP7+Ub4okTJ9IGxM3NjeIgeHejHBAVcgQCgUAg0AW9aY69evUCIKnHTZs2pdeDg4OpyXBYWBjt6Lp27YqZM2fCysoKgPymVACIiIgAIBUU58nEHC6XmZkZ6tWrB0CqpG9vb6/y98jFzp074eTkRBFW6jDGaKfbs2dP6knXokWLfBU4zomsrCzaxemantG/f39s3rxZL33U8sr8+fOxfPlyrce5FjxhwgQsX75cH9fro9ccleFh9NeuXcOhQ4eoqtCVK1cozWPYsGH4/vvvKYnc0N0ceN3kvXv34q+//qKKXQqFguamTZs20bNtCB49ekRmZ09PT3LdDBs2DCNGjKAUFDkbG+dEamoqtm3bRtHI4eHh1NHn999/x4ABAwyaQcAtjIsXL0ZqaioAycUTGhoKW1vbbOd37twZFhYWZIJVjj6Ojo6mhhE6IJ9Z1cvLC2PHjgUgpWfQm/9nCuSNPUuXLk0tWLp06WLwTg2cq1evokePHgCkpqn16tWjxbFatWoYNGiQwWXauHEjvvvuO403Y/Xq1fH111+jd+/eAD50DZcTbnZes2YNlfPjkyJn7NixFH5dr169QnvIQ0JCKBeVl4/ik2DNmjXh4eEBQDKR64n/1OIo+HiIjo4mt4KbmxtevHhBikm3bt3IHfEfQ5hVBQKBQCDQBb1ojrdv36aIxjdv3tDra9euBfChBVVRqaNaFImJiUG3bt3IOW5tbU3m6PLly3+UdST/xQjNUfCvJDAwkFoIVqpUCZmZmdT0oGzZsnkxRX5MFF60qkDwkSEWR4Hg40GYVQUCgUAg0AWxOAoEAoFAoIZYHAUCgUAgUEMsjgKBQCAQqCEWR4FAIBAI1BCLo0AgEAgEaojFUSAQCAqR2NhYuLq6wtXVFd26dYNCoUDVqlVRtWpVrF+/HvHx8VrLSgrk4z+Z5xgfH4+UlBSV1wYOHAgA1N0BkCrFt2vXTqVlilzExcXh0aNH1AEEAJXaq169OubNm4evvvoKgDyd1fNDVFQUld27cuUKdY8HpNZZX3zxBQBg8ODB6NGjBxo0aFAocsrAR53nmJiYSGUB161bRzUrJ0+ejDFjxhisU4Pc+Pj40LP96tUrjBo1yqDj83ZLnTt3prrPALJ14OE1WD09Paklk0CviDxHgUAgEAh04aPVHFNSUvDo0SMEBwcDAE6cOEFazuXLl/Hs2TOV87X1c2zWrBnOnj0LQLXqu77Ytm0bAKkh5+PHj3OUie/Yf/31V9pNGpLMzExERUVhxYoVAIC///6bOjYo73w1MXr0aCp4LAe8bGGPHj2oBB8gXUNetrBu3bpo3bo1qlSpAgAYPnw4Hctj0fSPWnOMiIigZgHqDB06lJoFG7Jnp764e/cuzp8/D0CydvAuMuvWraO+pSdOnCCrh5zw3olt27al12rXro1GjRrh3r17ACSNlnP58mW0b99edrk4/v7+uHDhAgCpCfyXX34JQGqSoFAoMGXKFACAqampLj0TizLylo/jFyqnFkeaGvbymqErV67EuHHjdB1OK7GxsQCAfv364erVq9nGBzQ3Ks7pGL8hL1++XGD5lNm8eTM15ExLS8tmSuEdwaOjo+Hr60vHmjdvTh269dhpQitBQUEApA4mFy9e1Hpex44dVbqY37lzBwDw9u1b2RdH3rJq/vz5Kq9raxLN2bp1KwDgm2++yctwH/XimJycjMGDBwMAtVkCpObCaWlpdM85OTnRc/9vN/f5+/vjxo0bAKTNp3qHeTngY/DNBiDdv/Xr16cNOV+QAOl6u7i4yCbP6dOn6VlfvHgx0tLSqFlzTigUCmzevBnAh2bX+uSvv/7C27dvAUgNmMuXLw9AagmmvImxsrLKb3tBYVYVCAQCgUAXiunrg/jOPTk5GZGRkQAkx35mZibKlSsHIPsu/smTJwgNDQUgqe360Bx5H0J1rVGdnj17ApD6Nzo4OFBvSYVCQaYMe3t7vHnzBiEhIQWWSxn++S4uLrQzMzMzwy+//IIRI0aQXNzUl5aWBn9/f9rN3717F/369QMgmYCqVaumV/nU8fT0BABcvHgRpqamGDZsGABJ6+dNSCtUqICaNWvC2NgYgLSra926taxyKcPHatSoEVJTU8ksePfuXTL/FStWDH5+firv+/nnnwEAR48e/a/2sstG6dKlcerUqWyvnzhxArNnzyaz9Q8//IAOHToAAP37b6Vhw4b0TPHnTG5q1aoFANi9e3e2Y/yZU4Zr6frk7du3FIjk7++Pd+/e0TH1+Zo3suYatvJ5fN6VgxUrVlCgpEKhULHy7d27l2RUltfKyoq+x9GjR6NSpUp5HldviyNfAHljWUDqNJ2Zmamx8/qDBw+oQzcg/QH6gHeydnJyAgBSs0NCQujmUigUFPHJJ3NOVFQU7O3tAai239In3D8XGRlJX/SPP/6IH3/8UeP5JiYm6NatG7X+2rdvH5ksPTw8MGfOHFnk5PBxb968CRcXFzRr1kzrufyaffHFFxQRXLp0aVr05aJv374AQE2seSf6zMxM8iUpFAoVM9Gff/6JgwcPApAiF3k0sHLEsOADvXv3xvr161V8uv9mnjx5Qn7+JUuWoE6dOgBAjdsLC19fX9rEMcbg4OAAAPma4NU5fvw4xQy8efMGqamppKAAH8zjfKOwcOFCANIclJGRAUDyz27fvp3eU6JECdSvX7/Asmlj8ODBaNeuHf2/cePGAKR4kL///ptev3DhAh4+fAgA8PPzIxfQ2rVr4ebmludNjzCrCgQCgUCghkGjVd+/f08O/sGDB+P169dk3vTx8clrxGCe+fPPPwGomgWaNm2K0NBQCnBRznMEJK2HB8N8/vnnepVnyJAhOHLkCACgZMmS8PDwgJ2dndbzHz16BABo0qQJmQ+GDRtWZDSd1NRUWFpaApCaqnJcXFwwe/bswhIrR6ZPnw4AWL9+PeW6Ku9GtfBRB+RoIzU1FX369KEIRuBDkNq/wayanp6O169fkwvowIEDlFxvYmJC5k25rRw5ERUVhe+++w6HDx+m1/bv3w+gYHJxbXHRokVag2yaN29O1rWpU6dmO84tfTxYiFvp3N3dMX78+HzLJgfz5s2j75mbW3lkvQY0Ps96M6vqgpeXF/mrAMmnt3PnToOMfezYMYwcORJA3qJVhw0bphKBqU+2bt1K5t1Lly7Bzc0tx8WxKCdfe3t7Y82aNSqL4pIlSwBIvqmiyKlTpyi6un79+rJGAv5befnyJeLi4gBIaUfKC2NRJTw8HE+ePKH/83SpkJAQ+Pv70+vGxsbkzpk5cybatGljWEH/R3R0NG3YnZ2dcevWLZibmwMAOnXqpJf0jb179wJAtoXR1NSUFpEhQ4Zki1/gysLy5ctx5coVlfdxV4ahF0buuuH+R+XNLP/95MmTKnM5L2qRF2RfHMPDw+Hu7g4AcHV1pdSNHTt2oFWrVnIPTyg7mvPCnj17SLs7evQoOnXqpDeZKlSogB07dgCQKuTkFjbNH/KigqenJ21uzp49qyJ/yZIlKfz6r7/+woABA2inWZikp6dTCP306dPJ57xjx44ivfmQm/fv31Pe3bFjx2iTExgYmGNag7OzMwBpEh86dCj5o0uUKCGzxJoJCwuDjY0N+Z6UKVasGCpUqEAL4vjx42UNGuMLkjb4JL9hw4ZsQX9cE9+0aRP5QgsCr141evRo0pYbNmyImTNnwtrams57//49AMlKNXfuXLKocX8jANSpUwfz5s3D119/XWC5csPOzg5HjhxRUV7Uf9cUkPPZZ59RvMlPP/2UrxQP4XMUCAQCgUANWXyO/DPDwsIwcOBAim5r3LgxmTUKoz4oT3DNzazKw6jXr1+PuLg4OlaqVCmcOXMGgJTwbijS0tJw6dIlirZKSEignfmlS5dUKmzISUhICFxdXSlS9smTJ5S2kxszZsyAm5ubnOKpwLXW9PR08iWFhITg+vXrdB/07dsXCxYsAACVaDgd+Kh8jllZWViyZAkWLVpU4AG6du0KALC0tCTNom7dugX+XF2ZN28e9u3bh+joaABSRCPXfNevX48hQ4YYRI7r16+jQ4cOWgtQ5FScok+fPjQHya2Bp6enkwZ78OBBXL9+HYDkj1WWsWrVqpQBMG7cOFSsWFFWuThGRkZQKBSwsrICIMWq8N9zIo9zorwVcpThpjZeLYE7krlj+d9CdHQ0xo8fj6NHjwKQFs4TJ04AgEoair5ITExUCZNPTEwEIFXsUK6QY2xsjDVr1gCQikHLDZ9c6tatm82pzcPLx4wZgwEDBiApKQmAZCbm98H58+ehUCgoZLxmzZp6l5FPegkJCQCAFy9eAJDKCL58+VLlXO5/+PHHH8m3k0c+qsUxIyMDDRo0oGumDjeH57SBCAwMpPuVw7/nu3fvGqR4PycqKooWx6ZNm9JmaM+ePVi1apVBZLh+/Tq6deum1Z2jvjjy1Ai5TZWJiYm02d+4cSMCAwM15lSamJjA2NiYUjkmTZpUKG4Ra2tr+Pn5YfHixQDy5zvUAVEhRyAQCAQCXdC75ujr60sJpOnp6fj1118pPFg96vPZs2eoV69eXocwODwqi2uNgJRYqs9iu+/evcPYsWMp+AfQHkFbo0YNlcRdueGaY/369ZGVlUXObWdnZ3Lma9IGeZRj3bp1ERcXR/fBxo0b9Srfw4cPKYBBXXvRZL7iBeSPHz+e34CMj0pzBKRr+P3332d7fcCAARSExiukaCIwMBDJycn03Xp5eSE1NRWAFK3s6uoKAFSQIa+kpqYiOjpaa0H0nODPkZ2dHYYMGYIxY8bkS4a8EhgYSI0P1HFyclIpMnLr1i0AQMuWLWWRhafc9O7dO9szoomuXbuqWKsKixs3bqBfv360dly/fl0Ok65hUjlcXV0parFixYrIyMiAo6MjgA/mNU5iYiKZW+bPn1/kcmU43Dyo/GCql1AqKOnp6VofJHUiIiLI5zlv3jxZO3RERkZSmavHjx8jKSlJ524M3K/MJ8RLly7JIuPDhw+RnJwMQLrnLCwsVK4Jr/Dj7++PkJAQKvQ8cuRI8rFoquL0X6Jx48Y4efJkvt/PfTzcH7Ro0SLyYa5Zs4b8jv/P3nnHRXE+f/xzBBUUsSKWENGYWEADdqMCRo0Fo2I3MZYktthrvmCIDU1MotgSC0GDLbGXqGCJgsSCsVfEjsECNgQEFX1+f+zvGe+Oo+8eqPN+ve4lV3e8293ZmWfmMzm9oGzcuDEmTJiQYatTeshzjpWVFV2wqcWTJ0+ovaVOnTooVaoUPVe7dm2Ta1///vsvqlevTs6xYsWKmq/hyfOVXHbIjL1798LDwwOtWrUCoExgkceROalTpw5cXV0pMPH19cWCBQvMsm3VnaOLiwvpMsbFxcHb2xvFihUDoEjMyRNt8+bNMXXqVCqc0FKb71WgePHi+Pvvv0moADCMHC9evEhrnw8ePMDhw4cBKEOa+/fvTztubhyl3N6CBQuo/aZ+/foICgoCgGyXlEtpLuPB0mrTvn17+m6qVatG+5gxlStXxpMnT6iJed++fWTbm+4c1cY4wtMfvZQTnjx5QhN3ssvevXsBAOvXryd5QbWYM2cOvL29AQCzZs0iUYmMqFevHurVq4d9+/YBAK5fv07nQa10kgcMGAAAqFWrFq0xfv3116hQoQI56dmzZ1PLxqJFixAWFkY2FihQgHrUtZyuY4rly5fDzc0NgNLHKOs9cnKhlB14zZFhGIZhjFA9chw2bBhJiElkSsXZ2Rn3798HoFSwpqamkohst27d1DYlDWvXrgWgVLDJFoQ6deqQaHp66Iupa0n58uVpvmNG/PPPPxg6dCgAZWbib7/9hi1btgBQKgP1UzvZQc5kGzJkCFVxSvWMnDB37lwAoJRnTtaLsor+3LuMSExMpGZ3RjuM57pmJFafFc6ePZutdXaZPg0LC0OXLl0AKClfOVRALWTEByhr8PJcktmEIf3UoLu7e07nEGYZKXbh5uZGUZhELm3NnTuXqtF9fX3h4+NDYgoRERE0tWbp0qXo16+fpvbqU7p0aYoSp0+fTlJ4WkeOEEJkdFOVkJAQUalSJVGpUiVhYWEhGjRoIIKDg0VwcLDamxJCCNG9e3dRtmxZullaWgpLS0tRrFgxYWVlJaysrISdnZ0oW7as6N69u+jevbv4/fffDT7j8OHDwsbGRtjY2AgLCwu69enTRxObs8qjR4/Eo0ePxMiRI4WNjY3Q6XRCp9OJLl265Pgza9asKWrWrCkAiOHDh4vhw4fn+LPWr19P3zEAYWVlJcLDw0V4eHiOP1MNxo8fT79h48aNRVJSkkhKSsrux2R23OTXm+ZMnjxZTJ48WRQsWJD2SZ1OJxISEkRCQkKOPxeAcHFxEXfu3BF37twRQgiRmpoqUlNTRWxsLN1WrlwpunXrJuzs7ISdnZ3Q6XSiatWqomrVquLs2bNq/TeJW7duGfw/nZ2dhbOzs7h9+3aa1z5+/Fg8fvxYTJw4UQAQBQsWFAULFhQ///yz6napxbx588S8efMM/o8tW7Y0ux3yOHVycqLz8fnz59X6eJPHC6dVGYZhGMaY9LymUPFKc9euXWLXrl2iYMGCdNU+atSonFyxZ4q8mpwxY4bB1Y6NjQ1FkNbW1gbP6XQ6AaXMXeh0OuHo6CgcHR3FuHHjhIeHh8Fzrq6uwtXVVcTGxuba1lWrVolZs2aJWbNmiSNHjuT4c9555x36f1hZWYmjR4+Ko0ePZvtz9CNHb29v4e3tna33P336lK40ZcQob0FBQdm2R21WrlxpsA8eOnQopx+V1xFgvowcZcRoHDX2799fPH/+XDx//jzHny2Pv6JFi4qiRYuKLl26CE9PT+Hp6ZnmWNbpdMLJyUk4OTmJ4cOH53rbGfH48WPRtGlT0bRpU4PMkrOzswgICBAnTpygm5eXl/Dy8hIWFhZCp9OJt99+W7z99tvi6tWrmthmin379onExESRmJiY6WuvXr0q3n//ffH+++8bfLeDBg1SxZZq1arRZy5atChL76lbty6dU/z9/VWxQ6RzvGh6MCUlJYnx48cLW1tbYWtrK6ysrCh9+fDhw9x+vElu3bolbt26RTupm5ubcHNzM3AW4eHhYvny5WL58uXC29tbFCpUiH4k/R1c3uRzRYoUEQcPHhQHDx5UxdbJkyeLAgUKiAIFCggAokKFCmLBggViwYIFIjo6mlKnxkRHR4uIiAgREREhPvnkEwPn7ujoKG7evClu3ryZbXtGjhwpRo4cKQAIa2trYW1tLcaPHy/u3bsn7t27Z/I9Dx8+FA8fPhTh4eGiTZs2Bg5R3r766ivx9OnTbNujBgkJCaJnz56iZ8+ewsbGRlhbW4vRo0eL0aNH5ybNl9dOzqzO8e7du+Lu3bvCw8NDtGvXzuC5devWiXXr1gkXF5c0TrFWrVqiVq1aYt26dTndNBEYGCgqVqxo0hEWKFCAUm0dO3YU48ePF/Hx8SI+Pj7X280Ke/bsEXv27BF2dnZpzhumzifyuWLFiolixYqJVq1a0e3+/fua2PjJJ5+ITz75RFhZWYlGjRqJRo0aicjIyDSvk8HFlClTROXKlQ2+Z3kRoNb3qv/9ZOYcZdrc0dGR7NmxY4cqdoh0jhdN5ONSU1MBKIvSq1evpmkHf/zxh6Yq+ACo0EYWf5QvXx6AosCvr8knF/fXr1+PsLAwaiUxpXco+/W2bdumuqaqnJu2cOHCNNuuVasWgLSjqtauXZvmtXLBffbs2TmWlJPfQbVq1QymBMgWDlMamTExMQBezpqU1KxZk7QYe/bsSRPGtULux0lJSbh69Sr++usvAEoZv/48zk2bNtFkmFzw2okApMeDBw9I1OPQoUMoUKCAQduLlAvUn9oAKL//rl27ALwUXcgtly9fNhg5JSlfvrzqLRo54ccff6SxZ1KTOSNtVVk45+npSQU8bm5uORZKyAjZTqcvABAREYF69erRcX/ixAlMmzYNgDLFQ9/+YsWK0ZQRtfqq5cQNQPk+ZFFS06ZN00zakAVeOp2Oei+Dg4NVsQMsH8cwDMMwWUP1yPHEiRM0PSI6OhpOTk6kbiCjOC2RV7DfffcdSVZJ5P81O8OOAaV0Gci8PDsn3Lp1C4DSghEYGEhRzr1799K1yfiK9P3330ezZs0AqCPNFhISQs3MxhFhRtjZ2ZE0l6+vb6YtMtklMTERV69eTfN4VFQUiQBIwQJJuXLlqOx89OjRatn0xkSOUVFRqFatWpZeW61aNRKG7ty5MwoVKpTdzb3yhIeHA1Air6SkJBoWHBsbS030devWhZubG2VTSpYsqbldpiLHtm3bolSpUqSas3nzZoP3CCEoA/fbb7+hdevWqtr0+PFjasuYNm2aybmM8m95LqxRowZCQ0MBQE1VIW2ncly5cgWAIvMkFfGHDh2KsWPHmsUpGvPs2TMsWrTIYNLATz/9BMDQ2Tg5OaF06dIoXLgwAEUqTqYU27dvjxkzZqjeG5URsbGxAJQUlpSlsrCwwB9//EHfY9OmTWFh8TLoHzFiBN5++21V7ZCKJkuWLKH+puPHj6d5nUyFdOnSBV999VW66jS5JSkpCX379iVbMsLe3p60VufOnavFFJA3xjkKITB//nwAMKn+8t577wEAevTogUGDBmmm8MLkDlPO0RRyRFbBggXh5+dHyjpy2UZL5LGt3zsqkUtiGvWDclqVYRiGYbKCapHjN998AwD4+eefSdhZDpJlmNxy7949TJs2DStXrgSgXF3KKMXFxYWiQ09PT9SrVw/29vZamvPGRI7M64FUIDM1u/Hzzz8HoERlUmnKXAPU8wnaplU//fRTAErqjScdMK857BwZ5vWB06oMwzAMkxU06XNkmNccjhwZ5vWBI0eGYRiGyQrsHBmGYRjGCHaODMMwDGMEO0eGYRiGMYKdI8MwDMMYwc6RYRiGYYxg58gwDMMwRqg/OAzAsWPHAADnzp0DABw9ehSAMmtQMnXqVFLwNxf//PMPAGVmmpxN+M477yA0NBQdOnQAAMTHx9PrW7VqhZEjR5IYL5P/KVSoEJ4+fWrwmIeHBwCQmr+kZs2a8Pb2BqDMnGSyj5xHumDBApQrVw4tW7ZM8xohBE1GkdNjzMWIESMwd+5cABlPt9m+fbvqUyeYVxvVRACSk5MBAJGRkejSpQsAmBwvJClUqBDmz5+PL7/8MqubyDVyCPO4ceNw9uxZetx4BJQ8uYaHh8PHxwdTp07V3LYLFy7gwYMHuHDhAgBlssT69esBKE69evXqOHPmDABFOb9Tp04AAG9vb7ONBrp+/Tp27txJFz0nTpwgh6PT6eDs7IyNGzcCAN59912z2GSMlZVVGucop0ocOXIEJ0+eNJguIqcNvPfeezQVQE6ayAAWAfh/AgMDAQD9+/dPd7ivEIK+58qVK2PHjh2aTW+RyMk6tWvXxsOHDwFk7Bw//PBDGjelNadPn8atW7foODp+/DhNwdm9ezcA0EXGzp07zWITAOzYsYPOOYmJibh48SJNyNAffu7l5YWPPvoIQ4cONZttuWHSpEnw8PCgi2QTsAgAwzAMw2QF1SJHPz8/AEoEpD9Qds+ePXBzcwMA7Nq1C5cvXwagiJIvW7YMHTt2zL7VGiMHDrds2RJTp06Fj4+PZttauHAhAGWqiRw6mh0aN26MsLAwvPXWW2qbBkBJM69atQqAMizYOCozHsgsI4TAwEASozcnkZGRaR6TczBtbW1x9+5duhoeOXKkwZX5kiVLAAB9+/bNbDMcOf4/crj4+fPnceXKFdoPypUrR1HIzZs3cfr0aQDAqVOnUKJECZr5qhVJSUkAlKyLnIvq7+9vsP9qHTlGR0fjwYMHAIC//vqLvo8LFy4gJSUFVatWBaBMw2jcuDEAJQO3ZcsWGpL84sULVW3S5/nz55g+fTpmzpwJAHj06BHNQfXy8kKxYsVQuXJlAEDDhg3pfd7e3tizZw9FvuZk0qRJ9HuGhoZi7969Bssm8u9mzZqlWUbJwNdpO5Xjv//+AwCUKlUK1tbW9HhERARNbB46dCh27NgBQDlhyffkJ/7991989NFHAJQ07P79+zUb3/LgwQM4OTkBAG7dupXu66pWrYry5cvD3d0dAPDkyRNKZ8XGxmLs2LE0yFltDh06RAdugQIF0KdPH3h5eQFQxka5uLgAUA7+HTt20AmmcuXK2L9/PwCgTJkymtiWW/z9/TFmzBi6z85RG27evInmzZsDAC0baHnST4/ly5fj8uXLtExivObYqlWrXH3+s2fPsGvXLgDAhAkTcP36dTx+/BiAcr7r2rUrAOCzzz4D8DJ9b21tjSdPngBQajEWL16M5cuXA0CubUrPTgCYOXMmvL29MWTIEADA2LFjaWi6pWXacpTDhw8DAIYMGYJChQpRDYc5kI7OeM164sSJBs4yI7LrHDmtyjAMwzBGqFatKq84ANDVU0REBDZv3kzVqvkZeUU7ceJEutrr0KGDpkM/jx8/bhAxFilSBJ07dwagpDVq1qwJALCzs4Otra3Be6VdXbt2xdmzZ+lK3MJC3eudoKAglCxZkuzV/531cXZ2hp2dHUWOV65coYKs/BY5yopk/eppRl3Onz+PH374AYASOcp0t5WVFUVF5qZp06b48ccfDR77/vvvAeQuQpPFNBMnTqSMzrvvvosBAwZzWULNAAAgAElEQVTQspF+WtKYK1euUFR57do1BAcHo379+jm2JzOio6PJ3t9++w1ffPEFgLQFS/rcvn0bw4YNAwCcOXMGa9eu1cw+fUJDQzF58uR0o8LJkydrtm3VWzkeP36MFStWAECGB0FcXBzGjRtHJd41atRQ25Qsk5iYiF69egFQ2lAaNWoEAAgICNB0uzVr1qQWguLFi2PEiBG0DpEZsgIPAIKDg3H//n0AoBS2WkydOpXWk0uVKqXqZ5ublJQUbN++HXPmzAEA3Lhxg9JHlSpVot+deUlCQgKuXLlC969evUptUADw/vvvA1BSg9HR0Rg0aBAAYP/+/UhISACgpLOaNm0KQEk3apEqTI9z587h+vXrAAAfHx+DdbLvv/8eo0aNyvU2ZBX5mjVrsGjRIgBK9W5GbNy4EdOnTwegLKl89913AIABAwbk2p7MWLlyJQBlWSGzbgHZlvfll1/Sxe6SJUvQrl07TW1ML42aER4eHrT0ZOw09+7dm20bOK3KMAzDMMYIITK6ZZvRo0cLnU6X5ZudnZ2ws7MTu3btysnmck1SUpIoXbq0KFiwoChYsKDo37+/SEpKEklJSXliT1YIDw8X1atXF9WrVxcARPXq1fOFzePHjxcWFhZ0W7hwoVi4cGGe2iSEEKtXrxarV68WDRo0SLP/eXh4CA8Pj+x+ZGbHTX69ZYnU1FTRr18/0a9fP1GpUqU03xmUwh6h0+mEi4uLcHFxEYMHDxYlSpQwOK4bN24sGjduLE6ePCmePXsmnj17ls2vOWckJiaKqKgoERUVJfr06UM2WVhYCAcHBxESEiJCQkJU297Vq1fF1atXRVBQULqvefr0qdi4caPYuHGjaNiwoShatKj47LPPxGeffSbOnz+vmi1q8fz5c7FmzRpRunRpUbp0afHxxx+L6OhoER0drfm2J06cSPtYZreJEyeKvXv3ir179wohhMnXyOcywOTxonpatWfPnjh16pTJ50aMGIG6desCUFIa586dw7///gtAqYRq0aKF2uaky4kTJwAooXhKSgr8/f0BvFT8yI/IarExY8bg/Pnz9Hjr1q1RuHDhvDILgNL+or+GN3DgQFrLMDeBgYH0+wYEBOD58+cAQP/WqlULABASEvLKp4q1IDExkVpcYmJiMlyLOnnyJP0rhKC06o8//oiiRYtqb6wJ9u3bZzLt5+vriypVqqie1nV0dDT4V/LkyRNamlm9ejWJT7Rp0wb/+9//SJUrPyHX4wcOHIjVq1dj0qRJAJT1SXOR2TqitEXapi9EYup1GTT/Z4hqrRw5RRaWWFpaYvv27QDUXzcz5tGjR1ROvX37dsybNy/fOcU7d+4gIiICABAWFoaNGzciJiYGAAx6tTp27Ig1a9agQIECeWKnLLRo06YNoqOj6QSxa9cu6pEyJ5UqVUJMTAypIRnTokUL6tvMxX72WrdyJCcnU7+b7E8ElJN/1apVDXpbPT09AQD379/HpEmTMG/ePAAwu3qKLOf38PAwOEm6u7vTxZCvr6/m5xaJLLKRDrFbt24kl+ns7Jzm9bIt4urVq2jXrp1Br7jWxMXFAQAWLVqEn3/+GYBSXzBnzhz6fTO6QFIb4x5F/bVE6RABxSnKgh1jJk6caPDaTOBWDoZhGIbJCpoIj+eEI0eOIDExEYD2keP169cpSgXyVypVqvP07t2bIsWMuHbtWp5FjT///DNFCv/99x/eeecdEnnIi6gRUCr/0osaAUW7Ul7B+/v7GwhWMArW1tYUielnKQoXLpxhqrR+/frUilS8eHGqANeaL7/8kjR9dTod7O3t0aZNGwDKb1ysWDGz2JGQkIBffvkFAEjQXraKWFlZkVCHrP6V+s5SRUcfqa06duxYiprU0lCWv+mhQ4ewdu1ag64CqQb2+eefo1y5cqpsL7tMnDjRZKQo72e16T+35Ju06okTJ2inMc7da4EU7t60aRN8fX3xzTffAECer939+uuvAECqFaaoVq2agUzatm3b0LZtW81tM+bdd9+l8m6dToevvvqKStnzir///jtdJYzNmzfTyQsALl26lFMn/lqnVXPKtWvX8MEHHwAAZsyYQeuPWiHrFT755BNKDVapUgVz5841a7uIJDQ0lNS1AEMFnqpVq9J0n8wuGpKTk6lf8tq1a+ToAwMDc+yw5GCI2bNn03LN5s2bDV5jZWWFgQMHAlAClA4dOtC5OK/WjyXSSWa1r9HDwyM77RucVmUYhmGYrJBv0qrmRkZoMTExmDp1KlXn/fTTT2jSpEme2XXp0iUAitKNjIDs7e3h5eVFqYZ27dohKCgIgBJhDhs2DB9++CEAJZ1lLhwcHAwaxA8ePEhX8HZ2dmazQx+p4WmKZs2aITY21mzqHm8aCxcupMb/jMbVqYUUkJf7HABMmzYtT6JGAJg3bx4NAChdujSaNGmCcePGAVAEP7KTwpeZo8OHD+Pzzz8HoFSpL126FED2U6whISEAlCrismXLAniZ+tVHdhps2LABvr6+FDm2adOGRhG6u7trNuggu0ycOJGqUY2LsXJLvkqrSjUGKWZtDu7du4fVq1fTeoC+Wo5s78gL/v33XxIjNuWs5Xpkq1atcPbs2TyrEpRqSGPHjkVcXBz9nlu3boW9vb1ZbckKU6dOpRJvTquqS+XKlckpbty4UfOJO1LtxtPTk1RwhBBwdnYmp9S7d29NbdAnKiqK5CDlhawaLFiwAIDiMOWavqmh0hkh6znu37+fpVmaKSkpOHbsGK3rrVq1itZIBw0ahMmTJ5tVFlLaob/OaKoaVTpHNdKqqosAZBdXV1fh6uoqdDqdmD59upg+fbo5NpuGlJQUkZKSIgYMGCAsLS2FpaWlGDVqVJ7Ykh0mT55MQgDVq1fPMzvCw8NF6dKlSQDA19c3z2xJj2fPnokWLVpQU/jly5dz+lF53cyvughA2bJl6fbRRx+JcePGiXHjxomZM2eKEydOiBMnToizZ8+m+35vb28BQPTp00f06dPHbA3/Qghx8uRJUalSJRIssLCwEFZWVsLKykp4e3uLs2fPZmh7fkd+/wDEzp07xc6dO81uw+3bt8XkyZPF5MmTRZEiRUS/fv3EixcvxIsXL3L8mbJ5PwtN+llCXzxg4sSJ2XmryeOF1xwZhmEYxoh8teYoRbjzApnDHz9+PJYtWwZAKXXO7+i3fuQlTZo0QXBwMAlM//DDD6R4JIddq8Gff/4JQElbZbVyT6aUunXrhr///ls1W14nbt++TSmpO3fuUEpK6FVcFihQADVq1CABDUBJvwEv1/C7d+8OwPQ8QK2oVasWtm3bBkARxYiOjqZ2hRkzZtDUjICAgDxre8oNv/32GwDlHJVXVaP29vYkjv7gwQPMnj2bpnS4urrm6DNNzWYElJRodlRtZKpV7Qkd+co55gc2bNhAMmNZnZCRF8heHzlQOKc7qJrUrVuXTj5Pnz7F4sWLAajnHNetW0eDiFu0aIGtW7dm6X1yjJYsSpAndwcHB1Xseh3QXy9Mj2fPnuHkyZMkzWeq+MGcyi76VK9eHYAyes7HxwczZsyg5+TFrq+vL9599908sS+nnD9/nuz//vvvMxx99aojnVtYWFiWneOkSZMMnKJ+cU5u4bQqwzAMwxihSuR4+vRpKuEGQNqVnp6eWLNmjUklg+LFi8PT09NAQDuviIuLQ/v27QEo88tkilWmDbREVqSOGjUK0dHRNCtv+PDheO+990y+5+LFi1i4cCEAkBpMnTp1NLc1NTUV3377Lc3AM65G3b59O549e0b35aw/tUhISKB0WXh4OJYsWQIAGQqcDx8+nFKxAFCxYkVSyHkVU2xa0bhxY2rL6dKlC0VeMjMBKCnUefPmkd6qMKp0//jjj1GwYEEzWWyauXPnIjAw0MA2YztfBeRv0bx5c4oWv/rqK1U+W56rW7RoQYIAWUGKkh86dAhly5ZFhQoVcmWHh4eHSd8QGhpKKVd3d3eTKjmAEmEavz8ncxvTI1etHDK116NHD9y5cyfXxmitkBMbGwsABrb+/vvv2LVrF5UpA0C9evUAKE5eaxk02aNlXBbt5ORECiDW1tYQQtCJ6rvvvjPYCSZOnEjrARYW2iUD/P39MXbsWGrX0FfY8PPzQ2BgIDnrChUqkL1qpS9v3LhBbS03btxAkSJFABimUKZPn46TJ09i9erVAJQ+Mfkd63Q6g7WSXPDatXJERkaS2PiLFy+oDeOzzz6jde3k5GSsWLGCBm0XKVIENWvWBKC0G2jRgiVTitOmTcvS6y9evJgm3SsVZgICAvJMEi2rSAk62YPYp08fauVQS+pQrmH+/fff+OOPP7Js1/DhwwEoE0Z+//13dOvWLde2ZFf5JiP27t2b03QqK+QwDMMwTFbIVVpVpldyEzXK6qt58+ZlqTk1Ozx58oSUZNauXUuNwpcvXzZ4nRCCIrf58+fDy8sLAMyiAiH1Fh0cHHDjxg16/OzZs2jcuDEAJQX94sULitT1adCgAYYNG6ZpxCiRurNSrMHBwcFgfJE+Li4uqhe8ODg40MxIPz8/GgckKxWN/5bI3/Grr74yS6r8VaRatWrw8/MDoBSurFy5EoAi8pCe6sjgwYNJqFqrQhyZypPKUVlFpvx69+5N/6/8xM2bNymjcfXqVaxbtw4AsGPHDrz11lukAazFUARZvX39+nXExMSgfPnyANIewy9evMCBAwcAKPuErN6fMmWKKlEj8DJynDRpUo6iSA8Pj1zPbUyPXKVVo6KiAABHjx6lFFu9evXoy84K0jmaGk6aWxISEkwO6Txx4gRsbW0BKHPLHBwcSCRZSiuZm0uXLsHPzw8bNmwAAIM1XFM0atQIgOIMzFUh+Pz5cwQFBaF///70mLFzlGtOO3fupLYOLbh58ybmz58PQGkbSY8KFSpgwoQJAKCmEPZrl1bV59q1ayQgv2bNGqpidXJyQp06daja193dXfM1RjlMuVWrVgYycekxZ84cAIoYOaCsMZuL2NhYSgM3b94c5cqVoxS0fmX1ihUrcPv2bVrmAV6qgnXt2hV9+/bVNP175swZAMoUleTkZGq/adasGZ3HHz9+jNTUVFoasba2pukdcvKKlmTkKKUT1JeOyyUmj+c8l49jDJGjtH7//XcDDVAvLy8a5eXs7EwSdyVLljSrfU+fPqXBrJ07d6aD2tXVFTVq1MDHH38MAKpnAfIZr7VzZHJGdHQ0ydatXbvWoEdUn/Lly6NFixbUflK7du1sy8GpQXR0NLZu3UrRYVxcHAU8Tk5OKF68uIGec35fr80FvObIMAzDMFmBI0eGyT4cOTLM6wNHjgzDMAyTFdg5MgzDMIwR7BwZhmEYxojM+hxf1bUVhmHSwsczw2QRjhwZhmEYxgh2jgzDMAxjBDtHhmEYhjGCnSPDMAzDGMHOkWEYhmGMYOfIMAzDMEawc2QYhmEYI9g5MgzDMIwR7BwZhmEYxgh2jgzDMAxjBDtHhmEYhjGCnSPDMAzDGMHOkWEYhmGMYOfIMAzDMEawc2QYhmEYI9g5MgzDMIwR7BwZhmEYxgh2jgzDMAxjBDtHhmEYhjGCnSPDMAzDGMHOkWEYhmGMYOfIMAzDMEawc2QYhmEYI9g5MgzDMIwR7BwZhmEYxgh2jgzDMAxjBDtHhmEYhjGCnSPDMAzDGMHOkWEYhmGMYOfIMAzDMEawc2QYhmEYI9g5MgzDMIwR7BwZhmEYxgh2jgzDMAxjBDtHhmEYhjGCnSPDMAzDGMHOkWEYhmGMYOfIMAzDMEZYZvK8MIsVDPNqoctrA3IIH88MkxaTxzNHjgzDMAxjBDtHhmEYhjGCnSPDMAzDGMHOkWEYhmGMYOfIMAzDMEZkVq36WrJp0ybMnDkTAPDPP/9k+vpWrVoBACpXroxmzZoBANq1awdra2vtjNTj1q1bmDp1Kg4dOgQAmDt3Lpo0aWKWbatBQEAAEhMT4enpCQB4//3389gi5nXm0qVL+OqrrwAAffv2Rd++ffPWoNeA1atX4/79+wCAHTt2oH79+ihRogQ9/9577wEAWrRokSf2aYFOiAyru7Nd+p2UlIRt27YBAAoUKIC1a9ciOTk5zevc3NwwatSo7H68KgQEBGDgwIG5+oyVK1eiZ8+eKllkmi+++AIA8Ndff+Hu3bvQ6ZSK4zp16qB169b0uurVq6N9+/YAABsbG01tSo8bN27g0KFDePjwIQDAz88Pct+6c+cOUlNT8e677wIAtm7dmm8c5Pnz5wEAjx8/pr+vXbuGb7/9NqO3vTGtHOvWrcN3330HAHjw4AHCwsJgYaEknIKCgtCvXz8AQIUKFQAA4eHhAAAPDw9YWubNtXdwcDDatm0LANDpdPRbTpkyJU/seRU5efIkAgICEBYWBkC54Hjy5Em6ry9WrBgAYM+ePXB1dTWLjSpi8nhWfe8dOXIkfvvtN7pfsmRJ2NraAgAaNGhAJ/jq1aurveks4+TkhIIFCwIAnj59avBc0aJF6aB+8OBBup9x8OBBzZ3jvXv3DP6VHD16FEePHjV4TEZlGzduNOtJ6YcffgCgnCijoqIMnpPOUf7m//33HwDg+PHjeeYcFy9eTPve+fPn8f333wMArl+/TnYWLlwYTk5O8PLyyhMb8wNy3580aRJdNFhYWGDnzp2Udbl27Rr8/PxMvv+DDz6g59q1a2cGi18iMyyAsg8GBQUBUDIWvXr1MqstrwIvXrwAACQkJFDAsm3bNsTFxaU5htMjPj4egBIc5QeSk5PpQl1Srly5bH0GrzkyDMMwjBGqhxh3796lFMvWrVtRoUIF2NnZqb2ZXHHnzh0UKFAAwMvIUebPhw8fjtTUVADAtGnT0ry3VKlSAICaNWtqbue4ceMAKGnVjHB3d0efPn0AwKxRY1BQEHx8fABkfmUJvFxr7N69u6Z2GTNo0CAAStQohCBbjf+WJCYm4tixY2905Lh27VoAwNmzZ1GpUiUAyvc4c+ZMxMTEAFCyQsYMHToUgHI8yfV5c9K0aVODyBEAoqOjAQD9+vWDn58fpVnzcxR548YNAEqGSnLo0CHKvgDA22+/jVmzZuVqO5cuXUJgYCAAYMaMGRm+tlChQgCQZjksNDQUiYmJAAAHB4dc2ZMVLl68CEBZ+zx27Bg93r17dxw4cACAkt4PDQ01eJ+MkLOKJmdS6XhcXFy0+Phcc/XqVQr/y5Qpg4EDB5LNAPDhhx8CAEaMGAHgZTqwaNGi5ByLFy+uuZ0VK1akv21tbXH48GEAyolH2uTo6AhbW1uzO0UAmD9/fpZe36FDB5w8eZJOuOZm48aNAF46cPlvtWrV4OTkBAAoXbo0vb506dJvtGOMj4+Hv78/AOVia/bs2QCUfc3Pz4/SpBs2bMgzG43ZsmULACAiIoIubo1JTU3FhQsXaJ103Lhx6NChAwDFqTs7O5vF1jVr1qBRo0b0Hes7vEOHDpFjNKZhw4bkfBo2bIhGjRrlyo5Lly5hxYoVGTpFR0dHAMCff/6Jt99+G8DL9WXJw4cP8fz5cwAvgwetWLBgAb7++msAaS/If//9d5PvKVOmDMqXL5/tbXFalWEYhmGMeCNbOfTTvE+ePEGvXr2oFNkU+lGFOdFPp9atWxdVq1al+2XKlMkLk3Dz5k2KJE6ePGmQjuzRowe++eYbAEpBRn5g3759lP6TBQZubm4AkCbtwiisXr0akZGRAIDRo0dTJTQAhIWF5ctqxOnTpwMAnj17ZvB4y5YtKasSHBwMABRZ3r59G4sWLQKgRHPyvHDhwgVNbFyzZg0AJf3n4OBgECHKiPDGjRtwcHBAw4YNASgRoozYunXrpoodMr0YGBiYbtRob2+Pfv364dNPPwWADKNqc2TRZJZq9OjRGb5OnndsbW3p78GDB+eoAFR15zhs2DA0b94cgJLq0D+w8gvXr1+nv4sXL26WHzcnyL4iAPSd5jVbtmzBqVOnABimNXQ6HWxtbbF+/XoAQFRUFF1w5GV6PTIykk520t43OWWaETI1pn/RYPzb5UfH6Ofnh+PHjxs8Zm9vDwCYNWsWqlSpAgA4fPgwIiMj8ffff9PrPvnkEwBAvXr1srRunl3kmqG/vz8tK3Tt2hUzZ840y/qcKRISEgCYXmOcNGkSAKWNTDrlvKZnz560NJKamkpBQpUqVVCiRAmDtrxatWoBAHVI5AZOqzIMwzCMEapHjm5ubnS1efz48TSRo0xp7N69G3fv3sXHH38MwDxpQrntuLg4euzRo0e4cOEC9XIZiyIUKFCACnTMyZUrVzBnzhy637lzZ7PbYIply5al+1xAQIDBfXn13rFjR8yYMQNFixbV1DZ9ZHbA19fX4DcVQuDu3btms+NVQvaF/fHHH3lsSdaQv/G8efMM+pXt7e2xevVqAIbpQDc3N7i5uWHAgAFmsW/NmjUYO3YsACVdKvtDM0sNao0s7JNI4ZAlS5bQeUaLKDon3LhxA6GhoQa/rxQmkOcXrVDdOVpaWlKaMjg4GN7e3qSQs3z5cvz6668AXiqTyNdOnz4dgwcPVtscA+QPLkuBAaXZ+ZNPPqEmVmMsLS0pLVO3bl2qiJIqIVqxePFiav738vLCo0eP0LVrVwDA6dOn4e7uDgCYPXu22WTsssvt27cBAIsWLcKzZ8/I2RcuXFjT7Z4/f54Ocn1lIfmvXJ/69NNP81SMIr/x1ltvAVDW5OUF5K1bt/LSpAxZuHAhACA2Ntbg8ZSUFDrPODs7a15BmR5jx441WFccM2YM/du1a1dqicht1Wl2SEpKMrjoBl62rHXp0sVsdmSVQ4cO4c6dOwaPSQW2woULo0ePHpptW5OCHNkDOG/ePFSpUoW8/r1790jn8M8//8TTp0+pOOLw4cOaO0cpf3Tp0iWDx9NzjIASbcrihMjISIqKtb76e/ToEf0dERGB+vXrG1zNSTWa2NhYBAYGmuw504IOHTogIiIi3edlv+W1a9cM1q6WLFlCGrVaHoRHjx7F6NGj6eJLp9OliRwlAQEBue4Te52QF6rDhw+Hr68vAEVyTf6O3bp1MygKA172B1erVs18hv4/6ZXux8fHU/HLuXPnUL9+fQCgfj5zILcvo0X9Fo1Dhw5h7dq11I/ZpUsXcpRar0MeP34c27dvN3js33//1XSbuaFKlSooVqyYwTn6yy+/BKAELlOmTKF9VW3FMl5zZBiGYRgjNIkcJ0+eDECpioqPj0fZsmUBKFVa+qoZ//zzD1JSUrQwwSQygjWOHLODrOaqUqWKppW4ly5doihHKpLIHPu0adNImWbTpk0YNGgQRWVa880339DveerUKbJx4sSJJD4skdF1YGAgEhISsG/fPgDaRI4yUmzbti3u3r1La9g+Pj5o2rQpACWK6N27t4EIAJOWcePG0brswYMHqQVC/quPbHNycXGBk5MTics3bNgQ9erV09ROeQzMnz+fMikVK1Y0qEY/c+YMKeS0aNFCcz1kSaNGjbB//36DSFC2YsiIUUaS/v7+1LqhdeQohEhTV7F8+XIAyvla1oB07Ngx21qkWuDq6oqYmBhqH3v8+DGlgZ8/f47IyEj07t0bgCJ6LkXy1fgeVZ/KkR1CQ0PJWfbt2xdLly7VcnO0U7Zp0yZNKlWesKtUqWKwUyxfvpwOPP1UZ82aNXHy5EnNbP36669pTcXV1RVDhgyhSQNly5bF1q1bAQCdOnVC3759sXjx4lxt78SJE5q1XISEhGDWrFm0kP7LL7/QSCG1+PzzzwEAK1asgE6nQ506dQAoJ3R5Ao+Li4Obmxu1yCxYsACdOnXKyebyR7VC9sn28fz48WMcOXKE7sfExGDPnj0AlH45eYKPjY01OB7Kli2LM2fOANBeNeXmzZs4ffo0AOX41b/4/eabb8iuDz74ACdOnNDUloyQ35VUxJFtHmPGjDFbsU5SUhLJNxqnV/WpVKkSbGxsqL+wdu3aKFKkiKa25YSLFy8aDDFo06YNgIz/byYweTxzWpVhGIZhjJFhdjo3Tdm7d6+AcjUr+vbtq/XmREpKikhJSRH16tUTOp1O6HQ6Ua1aNREWFiaeP38unj9/bvJ9O3bsEDt27BC2trb0vo4dO2pq64gRI4SNjY2wsbERP/zwQ7qvK126tLC1tRXXrl0T165dy/H2ypUrJwYPHiwGDx4sTp8+nePPSY+ePXsKCwsLYWFhISpVqqT650+bNk1MmzZN6HQ6YWFhIfbt2yf27dtn8JpFixYJnU4n7O3thb29fW42l9lxk19vmnHv3j0RGBgoihQpIooUKSIA0G+SlzRr1ozOMba2tiI8PDxP7dHnwIED4sCBA8LBwUHMnDlTzJw50yzb3b17t9i9e7fo0aOHcHBwoHOaqZv87jw9Pel9ajF69GiRmJgoEhMTc/wZDx48EK6ursLV1VXodDrh6ekpPD09s/sxJo+XPJWP009tGlfBaYFUlV+1ahUpuTRv3hx169bN8H0yD9++fXusXLkSgKHKTm6Qcxlr1qxJMyYBpUVD5tkzel9iYiKePHlCaSV9sfLsoC+ltX79enTs2BEA8O2331J/Yk6VhA4ePIjdu3fTfbW+O33k+uHIkSPh5eVF64z625M9j40bN1Z9+286JUuWxBdffEFrld988w1u3ryZx1YZ8vTpU5oekR+QadYbN24YiI9LCTmtkGpbzZs3R2RkJPUuh4aGpploItm+fTul07dv3w4PD49c2zFr1iyaouHt7Z2jGo7ChQtTDQTwsnpaDfLUOa5bt470DIcPH2627VapUoU0QLOCLHXW7480HqSZE5KTk9GkSRMAyviZJUuWGJzU0yMmJoZ28CdPnsDGxoamS+SUjh07YvPmzQCU3kA5sPq3335D7dq1AYDabiTt27enfsuM+O+//9IMbFYbuXZovIZ4/vx5TJgwAQCoUMf4/8Goh/6JKi/5559/AChFWJKqVauidevWeWUSIcUB9Hsg5frjrFmzMHv2bOzfvx+A9gU61TVkPncAACAASURBVKpVo77fhw8fkgOcN28e1QhIZPHkzp07VXGOQ4YMIUm9zz//nNrAhg0blqHWtT6HDx9GSEgI3deXksstvObIMAzDMEbkWeR4+vRprFq1iuapaa2akh2kAPOxY8cQEhJCUlT6V6FqX4FevnwZnp6eVE1XuXJlg+efPXtGUzpGjRpFlbMFChTAypUraSBtThkxYgTJ68lKWImsVpSpXIm/vz+Vhbu4uMDd3R1z586l5+VzxlJUalx1ZoZMpXbu3JnaPNzd3TF8+PCcVqgy2UTNgeAJCQkG1eLlypUzqVIVGxuLc+fOkXLKnTt3aLnCHEPXZQR48ODBNCnKrMwzPXToEFavXm0WUfL4+HjEx8cbfC9yicnb2ztN5Kg28+fPpwjxhx9+oMrYlStXYt68eQCU7JSUtzPm5MmTNDUEUM7Juc2g6WN25yjHpaxatQoWFhYYNmyYJtuJiopCaGgo9d7pOzZT9/WRg5D1w3WJ1GpU4wRrbW1Njrd79+5ITEyEt7c3AEXiTPaMXbt2Db6+vrTeqc/XX39NkwVyg7u7O51EUlJSDCYXSDLSWzx16hROnTpl8jXyMVkKLvUmtcLPz48Orrt375JE3LJly/DOO+9ouu3XnWPHjlGa3RT60mTywlcNoqKi4OnpSVJi/fr1oxqC5s2b0/66Zs0ag2k2wEt5tl27dqlmT3rIVoz01u70kXKQ5p7Q8eeffwJQZB3DwsLIjujo6AzVr7RADpRv2LAhxo0bB0BJiffq1QuActFt7BzlRffVq1cN1rWHDx+u6pojp1UZhmEYxpj0ylhFDku/4+LiMnx+y5YtYsuWLQKAGD58eE42kS4xMTFi4MCBYuDAgaJ48eIZlijn5Na3b18RFBQkgoKCVLVbCCGGDh0qihYtStsqVKgQlcVbWVkJAPScpaWl8Pb2Ft7e3iI5OVl1Wx49eiRCQkJESEiIaNKkiWjcuLFo3LixsLKyonYMeZM2GT+u/1yZMmVEkyZNxNKlS8XSpUtzbJeXl5dBiXlGf+P/S9Dd3d3FuXPnxLlz59T7gvK+JSPPWjk6dOggGjRoIBo0aCBiYmIMnouKihJlypQRZcqUEZ999plITU0VqampamyW6N69u+jevTv9vpndqlWrlus2p+wgWzIaNmyYrk2ydSMvaNiwoShUqJAoVKhQls550madTidatmwpWrZsqck5RwghkpKSRFJSkvD29qb9KDObbG1txR9//CH++OMPER8fn9NNmzxeVFPIWbBgAQBFOk6mFBwdHQ1es3v3bkpH1qhRA/v27TNoX8gtnTp1wqZNm1T7PECpFvviiy8AAO3atSPlFS0YPHgwtVMYI4Sg9KmPjw/JTZmTrVu34sKFC7Q2ALxMk5ta//npp58AKJW4athrYWFBKVohRIZ/S1Wc4ODgDNOAOeSNUcgxZvLkySShaGtrSynr7t27Y+7cuTQhZvfu3ShfvnxuN5cGuf49Y8YMrFu3zuRrdDodtYbt2LEjT1PpUoAceFl5as4pHMZ88MEH1PYFKMemfhuJMXLduEqVKqTYZY61WymZ+csvv6SZyiGXngCl5iKn7Wt6sEIOwzAMw2QF1SJHeTXy0UcfwdbWFgCoqVPOhNuyZQtdWR47dkwNj2/ApEmTMGXKFADAhx9+iFq1alGPon6lZfny5Wl8lVyMljbWrl2b/nZ0dETv3r3N1rv17Nkz6s8aPnw4zp49S8/t3r2bmtdlIcKbRvXq1XHhwgUASoQooxZjzUcvLy8SpdaINzZyvH79Ol25mxqKLEWgg4KCcrupTJEiGQcOHMCDBw8AKPtIo0aNzCYw/qqxZs0a0nEtVaoUfvzxRzrnmGLQoEHmMi0vMXk8qy48/vDhQ/j7+wMA5s6da9As37VrV8yYMQMAct16wLx5PH78mGZrAi9VcfKgDeiNdY7Ay1T6kiVLKMUaExMDJycnmsgjh00zzCuAeZwjw7wBvNHOkWFeM3jNkWEYhmGyAjtHhmEYhjGCnSPDMAzDGMHOkWEYhmGMYOfIMAzDMEawc2QYhmEYI9g5MgzDMIwR7BwZhmEYxog8G3bMvJpcunQJVapUob9TUlLouaCgICQnJ9P9ffv2AVDmQx47dizdoaUMwzD5jTfSOa5YsQLjx48HoGiqli1bljRW+/fvj3v37gFQlOjffvvtPLGxbdu2CA4OBgD06dMn3ckCLi4u8PLyynAQsVr89ttvGD16NE0LP3LkCBITEwGYHoQs1Zd0Oh3OnDmTJ5NEGIbJPYsWLUozRFpSsGBBjBkzxswWaQ+nVRmGYRjGmPQGPQqVhqMKIURYWJgICwsTbm5u4vr16+L69ev0nBxEeuTIEREcHCyCg4PFwIEDaaDloEGD1DKD6NevHw3ObNWqlWjatKnJoZqTJk1SfdtZxdPTM90BpDY2NsLS0lJYWlqKQoUKidu3b2tqS2RkpIiMjMzxsGMLCwuxfft2TW3MComJiQKAcHZ2Fs7OzuL+/fs5/ai8HlqcZ8OOmayzYMECg+O2bt26om7duiI6OpoG+yYlJYno6Gi6RUREiFGjRglbW1tha2sr2rVrJ+7cuSPu3LljVtu7dOlCNtja2gpLS8sMhyLL172imDxeNE+rxsXFUch99OhRtG3bFgDg6uqKyMhIREdHAwDu3r1rkIbTMk3o6uqKuLg4AMCmTZuQmppKY6oWL16MZ8+eAVAGuOYHhg0bhsqVK9P9Xr16YevWrQCAChUqwN7eXtPty+/j6dOn2Xqfh4cH/Z2XA17lOKOOHTtCp9Ph3LlzAIBPP/2UUtfM60FSUlKaEWZZ4d69e3j8+DEAZQRayZIlc23L119/bXAeO3bsGACgYsWK+PDDD2m6SUREhMG5T59t27bRgPiMRkupwb59+/Dpp58CUKas6NvSsWNHFCtWzOD18vtau3YtEhISNLUtL9DcOUZHR9MsRSEEnZjOnj0LnU5H44b0p7V7eXnBy8sLAGhmn5o0adIEI0aMAADcv38fdnZ2cHR0BABMnz5d9e3lli5duqBp06YGj/Xp08ds2y9VqhQAxRHLCd0A0LNnT5QoUQIA0KFDhzST32vUqGE2GzNCXkgYn1zu3btHB3XRokXNbterSHBwMK3PZ4Y8pnx8fFCvXj0AQPHixTWZJD9nzhwAQEBAAMqVK0fO7ZNPPknz2rCwMADAtWvX6LEzZ87g9u3bAAB3d3eEhoaqbqM+Bw8ezPJr33//fQ0tecnatWtx8+ZNuv/uu+9i1apVAIAPPvgABQsWNHi9vGj28fHBoUOHzGKjOeE1R4ZhGIYxQvPIcePGjRSe60eEMqqQkaMcXMvkP8qVKwdAuZL877//6Ep27ty5qqSftOb8+fMmHz969Cjq168PABg5ciT9X7IaGb1p3L59Gz4+PpROywyZJerVqxc9VrFiRWoFAoBdu3apYtuFCxcAKBmps2fP0uNr1qzJ9mfpD9TODXXq1KFUak7x8PCgLJdWnDlzBgDw33//0WMtWrTAr7/+ivfeey/d9xUoUACAElV+8MEHmtqYF2jqHOPi4rB+/XrKp69fv17LzWUZe3t7atFYunQptXVIZO/e8+fPUbhwYbO0SbwK+Pv746OPPoK7uzsAvBKO8eeff8asWbPo/rhx42i9OSgoCFFRUQCU9SELCyWRMnz4cDg6OmLLli0AoEka8FXi0aNHAIDWrVvj1KlTKFSoEABlLVweO+vXr6fvFQCWLFlCaTd9UlNTERkZqWrKffXq1Vi7di0AwMLCAvXr14eLiwsAYPPmzRm+t2rVqgAM18TVqDUICwvDkSNHTJ47qlatigEDBhg8Js+R5cuXR48ePXK9/awSHR2Njz/+GIBy8ePg4ABAvYuWvOTu3bsAgMuXLwMAHetXrlyh10ycODHd93NalWEYhmGM0DRy3LhxIy5cuIDOnTtruZlsU758eWpkT0pKAvAyLTNnzhyEhIQAUBbsBw0aREU6xYsXN5uNXl5e2L59OwBg2bJlqFOnDqWgzY38blq3bo2EhATs378fgHLVqS9OcPfuXarAA14WuVhbW5vRWgVZ8KCfFShSpAhmzJhB99u0aYPr16+nea+dnZ1ZC57yO/J4OHXqFACQmMOPP/5Irxk4cKDBe7799lvN7frhhx8AwCAzsHbtWqruBIAFCxZobocppkyZkqbqXtpiHDXmFcnJyZg5cyYVIlWsWBE7duzIY6sMmT9/Pr777juDx2SkKzM9Ejs7O5w+fRoAcOLECcpcSKESSbFixSizkFHkqIlzlA5n9uzZeOedd0zuoEePHkVAQADdr1atGkaOHKmFOSaRqRNfX1+UKlUKvr6+AICEhAR8+OGHAIAyZcpg4cKFaNmyJQDQeqk5qF+/PmxtbQEAgYGBuHTpEsaNGwcAaNasmVkdzrZt2wCA0mZyDa9ly5a0kwHAli1bDNo95HNjxoxBly5d0lS7acWlS5fQu3dvAEppvEz/bty40eB1vLaYPs+fPwcArFq1Cl9//TU9/vXXX5s17Zcec+bMoQudhw8fYu7cuQBg4BjzkkuXLqV5TFbtR0VFoVSpUtizZw8A4Pjx49i7dy+Al60c/fv3BwD069dPMxsnTpyIefPm0f3+/fvnqA1GS/78809qxZKsXr2a/raysqK6gZiYGDg5OQFQ1kxlWrV06dKoUKECatasCQCoXLlylgIdTqsyDMMwjDHpqQOIXChqTJgwQUyYMEFYWFiIzz//nB5ftGiRaN26tWjdurUoU6ZMGhWVqVOniqlTp+Z0s9li/fr1Yv369WSDVHjYuHGjSElJESkpKSI5OVkUKVJEtGvXTrRr184sdukTEREhIiIiRI8ePYStrS19V+7u7vScORgyZIgYMmRIpio4GT03cOBAs9i6Zs0a4ejoSDaUKVNG7N27V+zdu1fNzeS10o3mCjmhoaEiNDTUQAWlZMmSmqsxZcaxY8fEsWPHhKWlJalode3aVcTGxorY2Ng8tU2fjh07pntcFC9eXJQtWzZLx9HixYs1szEjFa4hQ4aI5cuXi/j4eBEfHy9SU1M1s8OYuLg4MXToUDF06FABQNStW1ckJiaavD1+/FiNTZo8XnTi/6uk0vOdOXG4gwYNAqCozZQuXZpSBbGxsdTU37p1a/j4+FCqrn79+pQbPnr0qIEogJasW7cOKSkpaN26NQAlBNfHxsaGKutCQ0PzbN1v1apV+P777wEo5eply5YFoFTjyQZrrZCCwz179sTevXuRmppKz8n9JzPhcQBYuHAhAG3XXH7++WeMHz+etrlixQr07NlT7c28quXLWTqez5w5Q0sJd+7cocfHjBmDGjVqpKuG0qRJEzg7OwNQyvzVrvKOi4ujtJl+Zayvr69BdapxGk6fdu3akUqXlkMFjh49imbNmqVZ7wKU48L4u0nvOLKxsUF4eDgAqN4ucfPmTbRq1cqg9SU9GwcMGEDryFp9b3LZY9iwYQZiI9bW1ujYsSMARaDhq6++AgC89dZbam3a5I6qiXOcPXs2AOVg0v+SfXx84O3tDQBpnEzv3r2xYsUKAMq0B3M5x8ywsbGhvq5Tp07RwZ8XyBz6yJEjsWnTJgCAra0tzpw5Y7a2ir///ttgrViffv36wcrKCgBw+vRpWqvcuXMnAJD81LFjx0g9RW2MnaOfnx/tcyryWjtHHx8fKnbJKSNHjjQolFGD27dvU+uFbC/JCXK9ftq0aRg1apQqtpni5MmT8PPzAwBs2LCBHjflHGVhW1JSEk0Fkq+VvZpdunRR3cbY2Fg6Xxtz9OhROnaBlwVYsvZBbfS/E9ku9M477yAlJQU3btyg55o0aQJAmRIk94fcbtrUg7zmyDAMwzBGaBI5SuTVUlYqyPz8/Khi1Jxp1cywsbEhYe9Dhw7lm4ZwmWKdMGECwsLC0miv5gdiY2MBKCn006dPU5vHmDFjDNoA1Gbr1q1o37493ZdVjaNHj1YrFfNaR47Lli1D3759c7WhihUr4urVq7n6DFPISOb333+nLIWxIDYAWibZs2cPpdVHjx6N8PBwWhZo1KgRDhw4oLqN+sgUtKnUpT4VK1YEoLQg6VdRax05ZsTTp0/pu9u4cSNatGgBAAbRpJoEBgYCUJr2Bw8eDABwcHBASkoKqfcsW7aMshqWlpb48ccfMXTo0Nxu2uTxrGmfY1acolw7CAwM1ESJRraVPHv2LNt9inv37sXTp08pBZhfHCOgiIBLvv/+ezRo0AAAzNYukRXKlCkDQEmjli1bln7r5ORkTbfbvHlzzJw5EwAwefJk/O9//wOg/H65Pem/CfTq1YuOG/31ZfmcjY0N3ZftCbL9SbJs2TJNbJM9bvLfzGjVqhX9vWnTJtSrV4+UUvTbkLRC9vpmddC3FMnPDxQsWBAdOnQAkLYNSgu+/PJLAMpaqL5EoZWVFUkOTpkyBZ6engCU9eOffvqJahjUPvdxWpVhGIZhjNBceDwz5DzH69ev01WemilVmdqZP38+VUtmhqzQGzt2LFJTU/NF03NGhISEUFVcftQ7vXTpkubRoj7W1tZUaOHu7k6CD1OmTIGHh4dmxUCvCxYWFpTWyogXL16Qao6dnR3i4uIo9ZaX8zuNkeeYfv36UdQIQHPlrq1bt6Jdu3ZZeu3Dhw8BAAcOHID+UlexYsVQq1YtTezLClI83hycOHECgJIViI+PBwDcuHGDMlCAIk4ho0hra2vcv3+fqullBb9a5LlzlOG6TqeDj4+PZtsJDQ2lCjepPJMex48fp3/feustEuN9U0hNTSXFkfr161M6ulKlSukqaMTHxxtUlJ09e5ZEn//880+D15rTgdeuXZsUXsaOHYv27dvTCZ3JGVKYv3///li5ciU9XqVKFVLDsrTMu1NLamoqSaLNmDGDbHzw4AEKFCiAadOmAQDc3NxU37asNB03bhyCg4Np4oWciZoe8hi5ePGiwfJSz549czzPcffu3QCUyR45+T1u3LiBJUuW5GjbOUHWKAAvB6t36tQJrVu3pt8zPDzc4PitXbu26k5RkqM9eMWKFZg+fTpN2cjpQOINGzbQjlqmTBlNi0qioqJocTwj53jmzBmDPry6devS4n5+Ql5lAUobjKmihOwiB7xOmzaNpK2Alz1YLi4uadZt5XN3795Nc5WZXu+WGlMPsoN+76p+fxyTfS5evIgpU6YAgIFjBJQ+1nfffVezbScnJ9M+GhISQprH+hdsV69ehY+PT5oLMkA57teuXZvl9crscvr0aXTr1g2Acr4RQmDRokUAkOGFf1RUFH2nxmQ0MiozZK+qh4cHJkyYAEAp/MnqZ/7666/UPgZo2xcKvFxHvnz5Mp1Lzp07h/nz59PoL2tra6q36Ny5M7XKaAGvOTIMwzCMETlq5XB3d0eNGjVypXi/YcMG9OnTh8QAgoODNWnfkCkgDw8PGqj8+++/p/v6Tp06UYM9oKxXqH3F9M8//wBQZknK8uWsIEu6p02bRuLf77//Pnbu3Iny5cvnyqYLFy5Q9Z6+eDiQPRWc9J4rUqQIlVxPmTJFlbSbVN2/d+8epa3kAFZ9pIhzYGAg7O3tcevWrdxu+rVs5ZDC/5UrV6YS/itXrlDpfnBwMM6dO2fQgC8jxSlTpqB9+/aaCVeHhYWhX79+VENgb29P4vKWlpZYvnw5AEUcQN++EiVK0ASepUuXGlR5q83BgwepQR1Q9n9ZxSuPecnNmzdJQHv27Nm0JGF8HD18+JAqXrOLXHf/888/qY6ifPnyJNQNKNGaqdYMIQS2b99Ox1iDBg1oSlCJEiVyZE9OSUxMpEjy7bffzvW5zgTqKeTodLoc9yLK3scJEybg/v375GC1VtMPDg6msuSePXti0qRJ9NzOnTspvfvff/+ROkNAQAA+++wz1VtM5E47d+5cBAUFAQA8PT3pb2OuXr2KFStWUFpYv0goICBAlRPSrFmz0lW+yKlzlBc+06ZNQ4sWLVQdcAsoCiSAsu4g08xSeV8WAH3//ff45ZdfACgnmvHjx1OPaC54LZ2j/A2zur8PGDCA2mS0LnLKqk3y4mjEiBEAlCkilSpV0swufY4ePUrO8cmTJxBCkDPeuHGjwdrYsWPHDKb86B9HhQsXxsWLFwEA5cqVy7VdkZGRdH69fPmyySHUxkgVH2nz3Llzzd5naUZYIYdhGIZhskKOIscaNWqgevXqVJCTGTIF2Lt3b0RGRgIA6tSpg1mzZplVCUemivTngRnz3nvv0eK1TNuojUyP9ujRg6LUt956y6Dx1RSygf27776jKzqpEpJb/vnnH9LCrFChAi2OJycnk/AxoKSm9Nsy9K94v/jiC7LH2dmZyvq1KtLQjxxlBsLR0RFJSUn46aefAAARERH0+ooVK+LKlStqbPq1jBzlDMLevXvT0FgnJydSd3FwcICnpyeaN28OAPjoo4/MJjpRvnx5g3R48eLFDQT3ZZP90KFD8fTpU82LR9JDFgn5+vqa1FAFMhYe9/DwwPTp07MsGpBdVq1ahSNHjgBAhpWo7u7uaNmyJc2TzG9zHlVGvbSqn58fZsyYQb11Op2O1nU6depEqVOdToewsDCaJC+EoPA+q45VTaR82aJFi8hByR4iKdlUo0YNzVsN5He+ZcsWqsLavHkzTp06RdVuVatWJTFi/bUVIOspptcdfeeoj/HJ55tvvgGgqP2rkabCa+oc8zP37983uHgsWLCgQf9bfkG2cjg7O+POnTtZdo6NGzcGoKRfM2v7YFSH06oMwzAMkxVyLDweGRlJ6cdNmzYZpNf0/y5dujRFi/3796eK0byai8i8PsjCggcPHlAx09SpUyGEoMb/zp07U2SpYmM6R45Mhty6dQvt27enzJA+MnKUzf3t2rXDd999BwA5rkxlcoX55jkyzGsOO0eGeX3gtCrDMAzDZAV2jgzDMAxjBDtHhmEYhjGCnSPDMAzDGMHOkWEYhmGMYOfIMAzDMEawc2QYhmEYI9g5MgzDMIwR7BwZhmEYxgjV9LT0kYM9N2zYgCNHjuDTTz8FoAwOlvj6+sLa2lqLzRsgB3v++++/Bo/36tULgCLXVKNGDTRt2hQAULJkSTg4OGhu1+uCnKPYqVMnFClShIa7Ll68GFWrVgUAtG7d2uA9vr6+LK7MMEy+RjX5uNTUVADApEmTaHBwRsNxIyMj6eSpJTY2NgCQ6TgoSZkyZVC5cmUAyviqgIAAs43lAYA9e/YAUJy3/ogeZ2dn0ggVQmDdunUAYDA+CgDmzZuHoUOHamqj3Pby5cuxZcsWAJlPCqlWrRrZ1bdvX021dZ8/fw5/f38AyiR76Zzbt28PAAgJCQEAdOjQAU+fPqX3LVq0CIAyxDcTWD6OeaV4/vw5AODAgQMUvOzfvx/btm3L0edNnToV3377rWr25TEsH8cwDMMwWUG1yHHnzp0AlBSa/lQOY+RUjsOHD1NUpxUrVqzI9cDia9eu0VxFc+Dq6gpAmVWY3veY0bDUZs2aUfSpBZMmTaKhyImJiWlslANoP/jgA3Tv3h0AYG9vjwoVKqBEiRKa2aXP0qVL8eWXX9J9uZ8dPnwYc+bMwR9//AEAePTokcH75s+fDwA00SMDOHJkso0c9P7TTz8ZDBru2rVrmmHC1atXBwC0bdsWzs7Oud62XP7Qn3363nvvwdPTE7a2tgCUc0dWWLduHSpUqID//e9/ubYrn2DyeFZtzTGjE7IczdK+fXu4uLgAgOaOEXg53Dg3fPbZZwgPD1fBmsx59uwZjWECXl5ItG/fHpUqVcLVq1cBKI5Q7uQ1atQw+AyVhvma5PHjx/D396ch1/rUrFkTU6dORZs2bQAABQoU0MyOjEhKSsLkyZMNHpP2urq64smTJ/S4o6MjpXqtra1pYDeTMTLdP378eHz00UcAQBPj0+P48eMAgIcPH6JOnTp0Qn5TSEhIoLqGe/fuGYz2k8sUgFIDob9UYm1trYpzLFu2LACgePHidAH+999/5+iz3N3dc22P1iQnJ+Pu3bsmnytcuHCWah44rcowDMMwRqgSOYaHh2PVqlV0X16ldOnSBT179qRUW15FExKZBhg9erTB4y9evMDixYvp/oMHDwAoVx8yvWEOtm3bhnPnztH9gIAAAECTJk3MZkNGFC5cGN26dUNgYGCa54YOHUoFL3nJvn37DKqi9ZFRo0wfBQYGwtHR0VymvRakpqaiT58+AIDdu3dj69atAIDp06dn+L6YmBgAQEpKCipUqIAbN25oa2g+QUaH/v7+uHfvHgBlCaJmzZpU2e3q6oqaNWsCUCI7/cxM3bp1VbFDnpOrVKmCw4cPq/KZ5sDPzw979+7N9vvu379PqWRjypUrh5s3b2b6Gao4x/v37xvs7H5+fgBgsO6TH5AVkqVLl07zXH6ovNq/fz8dTBUqVMg3TlGSnJyMv/76y+Rz48ePx+HDh9G2bVsAgJeXlzlNIwoVKgRLS0uqnjZm4MCB+PHHHwHw1PWcsGfPHuzevZvux8fHG/xriiJFiqBFixYAgBIlSqBTp06a2bd06VJMmTIFCxcuBAA0b94cKSkpABTHfuzYMVy7dg0AcOPGDZw5cwYAcPHiRYP/Q61atbD5/9o787ga8/f/v04SjVTWIsTYskdUhjGWKUL4UJYxmAnD2JkmMsYSM2I+9u9gGPueNaYQxhYtimnKljCpmSxDRNl7//64f+/LOadTTqf7Pic+7+fjcR7qnNN9X+5z7vt9X9vrCg0tki0RERHYvn07AGD9+vX0/Oeff44NGzYUaduGMmbMGHzxxRcAgPPnz2vkIIsL+/fvp5uukJCQAr9bBeHo6AgAqFq1KhwcHODp6QlAyrXqg2w5R/UCkaZNm2q8lp2dDUAqMuFlxCkpKahTpw5SUlIAADNmzICDg4Nc5gCQeu9GjhwJAHSCcPgixA8877ksVaqUrDYUhnLlytFx9PX1LfC92nkJY5Cbm0tetTaPHj3CmjVrqNCgSZMm1iUo/gAAIABJREFUdHHhX1Jj0LFjRzg4OCA1NTXPa0OHDsXPP/8MMzORTTAU7jUCgLe3N0WFtOnfvz/VFZQoUQKVKlVS1C4ecRk1ahSePXuGcePGAZCuS9evXwfwpt2Mf/4ffvgh9TR7eHigWbNmAKTvrq2tbZHs2b59OwYNGkT7+uabb+imgO/HFAwePBjjx48HACxcuBCbN282mS3qvHjxggr9goKC6PpmZmYGW1tbPHz4EADg5+eHyZMnA5Ccsv3791MkyNHRkT7jtLQ0+m6WL1/eIJvEVUIgEAgEAi0UUchRv5uMiYmhKsCkpKQC2xN4jk0urKysUK1aNQCSp7pz504A0l0mrwrdvXs3gDdKOl5eXhQazO+uWCmWLVtGP7du3Zoq/I4dO4Znz56RrYwx8oRVKhW6du1KKkQuLi6K2VemTBkcPXoUycnJ9NySJUvIjuTkZMrr/fnnnxRKi4iIQK1atRSzS5svv/wSM2fOzPP8yJEjhddYBNavX4/79+9TJGDZsmVGbXPKj7S0NLRp0wZA3giRg4MD2rdvD+CNp8jTFUoqYe3duxevX79GSEgIANOlGXTBw6rqoV5TExUVhcDAQPqdV5H37t0bTk5OJNBRp04d6n4AAHd3d53b067iNwjGWEEPvdi3bx9TqVT04Fy6dInVq1dP4zVIvVYaz/FHbGwsi42N1Xe3erFu3Tq2bt06nfvL71G6dGlWunRpFhgYyHJycmS1pyDs7e31Ola6nqtYsSKrWLEii4+PN5q92qxZs4Z16dKFdenSRcO2AQMGGNWO58+fMx8fH+bj46Nhx4QJE9jr16/l2MXbzpvi+jCI1atXs9WrV7OSJUsylUrFSpUqxUqVKsVsbW3ZvHnz2Lx58wzddJG4efMmu3nzJmvWrBmdK0FBQezVq1csNzeX5ebmmsQuxhjr27cvU6lULDQ0lIWGhprMDl1cvnyZXb58mZmbm7Nz586Z2hzGGGN+fn70GXp5ebHXr1/Lda7qg87zRdxGCwQCgUCgTX6rJiuC55iQkMASEhJYmTJldHo9AJibmxs7c+YMc3NzY25ubkylUrE1a9awNWvWyHpLkJyczJKTkwvlOao/OnTowB4+fMgePnwoq126sLe3p+Oj/rC2tmadO3dmI0eOZCNHjmQzZ86kR2BgIGvSpAm9t1y5cuzWrVvs1q1bituri6ysLJaVlcX69++v4YknJiYa1Y7s7GyWnZ3NevfurfF5btiwQY7Nm9oDNJrnuH79evIUdZ0fZmZmzMzMjC1ZssSQzRvMy5cvmbOzM3N2dmYAmKenJ/P09GTJyckm9Rg5169fZ2XLlmUWFhbMwsKCLVq0yNje0FsBwJYtW5bv62lpaez48ePs+PHjLC0tTVFbWrZsSdewsLAwRfelA53niyzycaGhoejVq9db32dvb0+x9+XLlwMAtQao98jJKUrOcxDt27fX6O/hVal8OgcnOTk5jyLOhAkTAEgtKkoKZjdo0IBUcBYuXIg+ffoAAMzNzQtUdLh06RLlUR4+fIgFCxYAACZOnKiYrW8jIyMDrVu3BgCkpqZi0KBB2Lhxo9HtePnyJeWd7927B1tbWwQHBwPQS2A8P957+TguddaoUSOqE6hbty5Gjx5NVZfr16+nY2ltbY2IiAhZ1Fz04aeffkJAQIDO15ydnUm6MCAgwGR55ri4OLLj5s2bGDRoEACp/9vDwwOlS5c2iV0cFxcXZGdnIyYmBgCwdOlSqmtITU3Fy5cvaWDDBx98QLKKEydOlF2Jq1OnTqSyVq1aNdoXzy/y9aVEiRKy7vf/o/N8lmVxfPLkCb7//nsAwNq1a0mzUqVSwcbGhsq4f/zxR/j4+Gj87b179wBIHxTvlUxISMjTDlJUkpOTcfjwYQBAjRo10K1bNwDSwqNObm4utSCMHz8e6enp9Fr79u2xb98+AFBE/iojI4NaJQqbUOZ2+fr60kKamppq0tYUvjjGxMSgSZMmSEhIMIkdfFxZt27d8O+//8LNzQ0AcPLkSUMnrrz3iyPvBZ02bRoVtOzatSvP93727NkApFas2rVr49q1azKZWjDXrl2ja46joyO1XlSuXBnx8fHUXzhw4EC6WTTmdB0Ov6b169cP0dHR9Lyvry927NhhdHvUWb9+vYbsX8mSJVGnTh0Akn3Nmzenm6SzZ8+SfnarVq2wc+dOEhaQg6ioKLrpun37dp7XdV1v3dzcMHnyZCr249OUDEBM5RAIBAKBQB9km8rBOXr0KAnpdu3aFa6urnrdYXz88cckEDBlyhTMnTu3sLuWnbt376JOnToack48NGIqhYu3UaVKFdy5cwcAcPjwYXh4eOj1d+np6STIwD2FolJcPEfOzJkzERQURL/36NGDPO5C8t57jpzk5GSN0nltuMJM06ZNYWNjk69IhLHhIgCrV68m6TpDm8Hlgtu0du1aZGdnUxTtp59+MomMYUpKCurVq4dOnToBkJrv+TmrC+6B+/v747vvviMlNLngHuOZM2doLQCk65i63BufwcqFAmxsbABIkTL+cyHRfT7nl4xkRSj9NoS2bdtSQrZjx47G3HWBpKenMycnJ+bk5MRUKhUrWbIkK1myJNu6daupTdOJelFPRESE3n93/fp1tn//frZ//37ZbHF3d2fu7u5MpVKxpk2byrbdomBhYUHFJDVr1jR0M6YurJG9IKdnz57s6tWr7OrVq4U6EHFxcSwuLo6pVCpWuXLlQv1tYblz5w67cOECu3DhwluLbnjxGgAqyisuREREsObNm9N52rx5c5PY8erVK/bHH3+wnJycQrWsdejQgdWqVUtBywomPT2dpaens9WrVzMvLy86jiEhIYZuUrRyCAQCgUCgD4oo5BQVHqopDjg4OKB///4AgODgYFKACQoKwoABAwzaJv//lS9fHlWrVpXFzsePHwOQ9CN5aKGgcJguuJpHp06dDK7K5cpDYWFhFKYFIGvyXiA/oaGhhQ6TZWVlYerUqfS7usKJEvj7+2PTpk0AgI0bN9J5qT7tJycnBzNnziRFlZ49e+otNG0sPDw8ULZsWSp6OnLkCKWRlD6G6pQoUcIgndei6s4WFa7BPWzYMHh4eFBIOr9pPIYiy+J4//59XL58GYCUeyhMJScvFVafys6loOTk/PnzCAsLAwB06dKFDmjZsmXzLal+9uwZHj9+THJZFhYWtDiqV7EWhqioKMrpTZkyJc9gXkN4+vQp/P39AUifxbBhwwAUTvC7atWqdByGDRtGF73Clubzijz1yQvm5ubFYmp4amqqLAOw31d4a8Tu3btJzP7Zs2fUDpWTk4OYmBi6uTt+/DhOnDgBQBqAO3r0aMXtu3HjBgBJQJuPnlNf/C5evIisrCzKnamP0itOuLu7Y8+ePQCk85SP/DLm4mgo58+fLxbj6QDQtU4JZFkcIyMjqX/R0dERX3/9NQCph7AgzygrK4t6zRITE+l5uXoc1Zk8eTJNvp4xYwY97+rqmq/GYlpamuyzzxISEsi74n2MRSEpKQn+/v7UpqJSqQzabunSpfHzzz8DkKYG8CT93Llz0bdvXwCStqq2Ji5fbHJycjB16lSsW7eOXuNtMt988w0p55sCfrwHDhyI169f0/NF6HN876hZsyYOHToEQLo55Xfnd+/epQIvXXfmvB9typQpis9rbdy4MU6dOgVAGmvEb3bj4uJoasPHH3+MNm3aUI+vqXsJC4JHe3iBSXGHa1OnpqbKcu3Kj9mzZ5ODNWzYMJQpU0bn+yIjIxEXF0e/yz3VSeQcBQKBQCDQQpZWjpiYGAoVPn/+nBQ16tWrh7Fjx6JLly4AJEV1Pg372LFjmDBhgkbDJ/87JVo5PDw8yHOUA0PL1qdMmYJ58+YBAPr27UtDlvkk8ILg5cxHjhwhJQuuMMTL1H/55Zc8QguFJSgoiMK96t+PgQMHolu3bhRy++233+jul+cr1Rk7diyAN5M7lOLOnTsUeWjWrFme2YE8lzZ9+nSN5zMzM+Ut/S7+5Hs+37hxg6bRqE9d0aZWrVoU2Zk6dSpNRdAW0xC8He51r1y5ks43LmxgTNRVcPLjwYMHNKXIzs4O4eHhiuUe4+LiSKjDwcEBAwcOJHGClJQUuo5funQJ2dnZ9B38/fffDZ1tq5xCDgAamjl48GC6oPIQHHeLLS0tKcSla7ozTw6Hh4fLLk80fvx4mg7ObTAEfjHdvXs3OnbsWOi/f/78OYWgDx06RGGf0aNHw8fHRyMMlJGRAUBSK7l8+TLlfh4+fEjH1sLCAg0aNMCaNWsAQLbJ3nzkk3pfoC60P2uuyLNo0SIao6WEmpA6ffr0wd69ewFIyh4dO3ak3tSkpCR6LSsrCxUqVCBVl+HDhxsqR/XeLY7Amzw6n8LOcXJyop/btm0rFsIikpOTgwkTJtCIvrZt22L//v0ApIHnxuSff/4htbDjx4/nWfCuXr0KQBpzxR2ZgwcPanwnlIDXKHBHQh1+rTE3N0dgYCD1jxYksfkWhEKOQCAQCAT6IJvnyNUKduzYQXp92sUbQF5PQ51ff/0VAODn56fvbgsFH+6pXWSzfft2Sujrgle29urVi4ZwFkHHD5cuXQIghVP43eOzZ890DoAG8h6r+vXrY/DgwQCkUnVZBntqwQtXYmNjydPiBRu6bHR0dMS0adPg6ekJAEYdgjto0CBs2bLlre+zs7PD2LFjNdoPDOS99BwF8sO1oytVqkQpiMDAQCxfvpwiSGvXrjU0vF9kbt++TWHyNm3a4JNPPgEg6ZZGRkZSRCo1NZW82+7duxvNvh07duDXX3+l6uN69erRtaVdu3Zy7UbZsKrAMM6fPw9Aysvt3LlTY5I5/2zKly8Pb29vCuN6eHjIHnZ+l3n48CFJFv7www+wsrLCxYsX6XWeD1+wYAGaN28uxy7F4ijQC76QpKSk0LmdkZGBIUOGYNWqVaY0jTh69CgAKQfKe5MZY1CpVBQ+XbVqFbXY6XJs3nFEWFUgEAgEAn0QnqNAUHje1VtncT4bGd5//NVXX1Efnru7OxYuXGhKswSaiLCqQCATYnEUCN4fRFhVIBAIBAJ9EIujQCAQCARaiMVRIBAIBAItxOIoEAgEAoEWYnEUCAQCgUALsTgKBAKBQKCFWBwFAoFAINBCcXn9qKgopKWlAQAWL16MqKgoAIC/vz9atWqFjz76CABQrVo1pU0xGK6JOHnyZKxYsQKApIs6YsQIU5pVLOCDo4OCgjRGje3atQtnz54FIE3oAEBaknwCukAgeDd58OABjTY7ePAgjdOrX78+/P39TWmabAjPUSAQCAQCLRRRyOHSSDExMYiJicGtW7cAACVKlKBpD/znnTt3ApBm8hU3cnNzceLECZoScuvWLfJwd+/eTcM//1c5fPgwDcjlQsUlS5YEIE314J81h8+N4wOalWDAgAHYvn07XF1dAQCtWrVC//79AUhz82Tif1Yh58WLF7CwsMjzMyB95nxwLgBcuXIFALB3714sW7YMgDSzNTIysqhmFAkevYqKikJ0dDQA0HUIAKpXr07XrP91+Dn8+PFjbNy4EQCwbds23L59G6mpqTr/Jjc31yi2PX78GEeOHKHhDRkZGVi3bl2e9yUnJ9Ow5HzQeT7LHladNGkSFi9eDODNBZMvwK9fv9b42dfXl/QGiwuvX7+mMTPBwcFYunQpDfCdNWsWjawy9lDS4sjs2bOhfnPFGMOLFy8ASMdnyJAhGu/v1auXYrbwaQLbt2+HSqXCuXPnAADnzp3D8uXLaf8DBgzQ+Ltt27YBkMZe8bCvQDdBQUE4dOgQ3RTGxsbSTQggjWfavn17gdvgoXZjEhISAkAK9asvgvnB00DFgQsXLiAsLAyAdLPBh8obg5iYGHz//fcA3kzu0IWzszNdD3v06KGoTdnZ2aRX6+Pjk2dCiJwTQ0RYVSAQCAQCLWTzHHkodfHixShRogQAyQsrUaIE3NzcAAATJ07UGOBbnEKp6enpAICNGzdi2rRp9HzLli2xdu1aAEDjxo1NYhsgzSzkXhkAukN/8OABVCoVzYpbt24dGjVqBAA4duyYojap2wMAI0aMwJw5cwBIYXNbW1tF96+O+iDmoKAgGga9bt06OlYHDx7Evn37dP69MQe4vqts3rwZKSkpFIpkjCEmJsbEVumGe4uLFi0ie3UxceJEANKkDD4TlD9nCh48eIDw8HAEBwcDAG7cuKEx41UJz/HRo0cAAAsLC1haWgKQCu3mz5+P58+fA5Cu1xUrVgQANG/eHFOmTKGhw1WqVKG/U4LHjx8jIiICAPDf//43z7B6pZBlcUxLS6MvFmOM4tTVqlVDSEgI3N3d5diNYoSGhtLFNCsrC6VLlwYABAQE4LvvvtPIq5iCmJgY9OzZk8K96vDQtTonTpwwkmWa9OrVCxUqVDDJvtVJTU2Fvb09AOkk5xW158+fx40bN/D06VMA0sLJ85E8rywoGjy3Y2VlZdT98lDookWLsGvXrnxDo76+vrT48enynL59+yprZD68fPkSkydPBiANFVbP2ypNfHw81QJUrlyZPr8//vgD9vb2+PTTTwEAPXv2NMkN5IULFzB69OhC34TVq1cPY8eOBQC6FhQWEVYVCAQCgUALWTzH6OhoKoBQqVQUVlWpVFi8eLFGKJX/PHHixGLjUSYmJlIvo6OjI/XhtWjRwpRmEZMnT9bpNXJ69uxJhU2enp6oXbu2sUwrlqxZswZxcXEApCpEfjfcokULjc900KBBJrHvXYN/99TDewDQsWNHfPvttxrPubi4AAAqVapkHOMghVB5b50uj3HBggUAJK+xevXqRrOrIBhjdM0cPHgw9QxqU6ZMGfr+yp2G2rdvHwYPHownT54AAEqVKkXXkf/7v/9DmTJlYGNjI+s+C8u5c+fy9RrNzc2pTx4A7Ozs8OWXXwIA3Nzcilw0KcviqB5KVf/51q1bSEtL07k47ty5E25ublQ9VlxEAGrXrl0sFsWYmBhqk+B5xWbNmgEAhg8fTvnPdu3amcxGbYYPH47hw4cDAJycnKiS0dHRUfF98yriJk2aYPLkyXRC1a1blypUfX19RUVqIbl37x6JOPC8PL9YK53T1pf09PQ8iyJfECdNmmQKkwokMzMTS5YsQVBQkM7XHRwcMH78eABA586d0aRJE1n3f+HCBQDAyJEjwRjDmjVrAEg3i+bmiuvC6MWDBw8ASIu0Oo6OjpQC6dSpU57QuJzI0ueYnp5OF6Po6GjKgbm6ukKlUlFCfPHixXn6HPnKb8repx49euC3334DAPTr14/K+00B93i6d+9Od+zW1tZYvnw5fHx8AIB6CU2Nq6sr2asLfpdeo0YNbNq0CTVr1jSKXffu3cMvv/wCAJg+fTo9/8EHH8Df3x8zZ84s6i7+Z/ocFy5cmEfxhLfNxMXFaeS73d3dTeaZadvBexmLE7wvsF+/fvkWlQwZMgQ///wzPvjgA0VsyM7ORr9+/QAA4eHhaNq0Kf744w9F9lUUVq9eDUBawNW5cOECmjZtKvfudJ7PIucoEAgEAoEWiijkFAS/o+vfvz9u3bpFd3yMMQqxcg/JGKxYsQKTJk0ibyw9PR3W1tZG27823LtSDxNVqlQJX3/9Nf3u6elJjdimCIOcPHkSgOTdZmdn6/U3EydOpFCXMeAqHYmJiVSReuXKFZQuXRp79+4FAHTp0sXQzb/3nuPQoUMBSCIJ2rnGWrVqAZDaDNQ9Njs7O0ydOhUAqFLQWPBKU34N8fX1BfCmpcNU/PXXXwCkinheNZ2VlaXxnsaNG1Putm/fviQ6ogTqIi3Vq1dHREQE6tevr9j+DIWnlNQb/gFgy5YtSlzzdJ7PRl8cOdHR0di9ezd9UMYOsfJ8Sffu3fH8+XNUrVoVADS+KI0aNcLSpUsVt0WdTp06AdBsx9DVrtG5c2cAUvjB2CpD3t7eAEDKHZwFCxZQfvGnn37SSKRXrFgRd+/eNZ6ROvDy8sLhw4epEKwIai3v9eJ47949dOjQAQBw6dKl/Dem43vJ257++9//Uh7YmCxcuBDffPMN/e7r62uyBfLWrVtUHKctpViiRAmyq0ePHlTEqKQtgHRjw6/5jo6O8PLyovds3LgRL1++pN8bNGhAOfqhQ4carS5k/fr15AzwXmoeZu7YsSO1l8h4AybCqgKBQCAQ6IPJPEcOTw6HhITQXeiZM2cUrUK6du0aeWhv01GsXr063T0bo7E5MDAQAKi8Wh11vVBOmzZtcOrUKcXt4pw4cYL0E9Vt7NatGzZs2IDy5csDAHJyckhL9ejRo8XCc4yMjES7du1QuXJlAMDt27cN3dR77TleuHCBWjIKomTJkhQODAsLQ0JCAr3WtWtXKnIzNtre41uucYrx4MEDOo66RLr5eLeAgABZNUF1wYXfeRWsOjxMaWb2xldijGl4kXZ2dlR9vmXLFkWuhdevXwcgRezU950fNjY2iIiIQMuWLYu6a+MIjxcW/qVQ749csmSJoovj0qVLqSyd75/38zg7O1Mrx6JFi5Cenp5HJs0QduzYAQD4559/KBygK3bOT5iCOHz4MH744QcAwOnTp7FhwwYMHDgw323Kyb179zQWRd5eor4wAlIYxM7OTlFbCkvbtm3Rrl07ypnu3LmTclOCN5iZmdG5+OrVK8rHu7q64tChQzovjJMmTcKnn35KbQKXL19GRkYGAElezJhMmjRJY9oGb+fgEpfGonz58jh+/DgAYP78+bh48SIA6ZwF3twIP3/+XKOqWgl4mNLGxoZyyKdOnYKnpyeFKXlqCQDu37+PAwcOUNrrzz//pGk6K1euVGRmI1eu0vd6m5mZiVOnTsmxOOqkWHqOvr6+tJgoQXh4OO23YsWK8PHxoZLh2rVrU0Ouk5MTAODff/8FAI2Lf2Fp3749AGmsCv+/OTs7G7y9xMREANLiVLduXcTHxwNQ3rv9559/SN9x27ZtVBi0atUqjfelp6dTDjk9Pb1YeI6A1E7EL5Y//vgjpkyZYshm3mvPEQD2798PQNLw5dKKbytg0vY4eURDxlFhesMjQjVq1KD2EiXGUL169YquW/rmDSMjI+Hr64s7d+4AkBaszMxM2W3TRUpKCt20fPzxx299P5ey27NnD30PrK2tcf78eXz44Yey2sa9WvXexlKlSqFNmzbo2bMnAEnujusjP3r0CFZWVjhy5AgAkIa3AYico0AgEAgE+lAsw6pKq+J37dqV5OJ0sXXrVvrZzs5OlqZ7rlqfkpJClabHjx9Hw4YNC72tFy9e4KuvvqLfXVxcFGsa1qZq1aoICAgAAPpXHR6ySUxMpNA1AFL0NzXqlb0RERGGeo7vPTyvXJj5fFzVhLNlyxYApvEc1cUIlJzP2LlzZyxZsgSA/lN7qlatStMujAX34gcPHkwhUX08R35d4RXqgNSKcuXKFdk9x9mzZwOQpn5wHBwc4OHhofG+evXqAQC+++47ZGdnU9V5ETxHnZh0cZw0aRKVMzPGSJnGlJqroaGhlM8rVaoUjhw5grJlyxZ5uzyUunz5csyaNQsA8NVXX8HT0xMACpVzmDlzJilsVK9eHUuWLNFIppuK58+f03BU9Z7GcuXKITQ01FRmaVCpUiVqN8jMzKQ+zTJlypjSrHeejIwM0rUEpAucPvlzpTBW+8bvv/9OOcTy5cvTeWhtbY3Hjx9TC8fVq1cRHh4OQBo79fDhQ9qG0jcP6enplEaqUKECPvvss0JvQ31SiFIFTry//IsvvijU33E1LLmdKtNfUQUCgUAgKGYY3XPkCjlLlixBSEiIxmBkJcqZeWXljBkzaFLA0KFD80wN4FV2fn5+ZEfr1q1lG3DM74qmTJlCxTlt2rSh4xESEoL//Oc/pDCia3goH7rMVSMAqWhIjmpabXjS3tLSssChxTw8dP78ecybN48KOQCQKv7w4cNRt25d2W00hPbt21NlckJCApXYGxLefp+4desWDa81hMuXL2uE0atUqaLosOuoqKgCK9rVbVEyElWzZk2MHj0aADB69GiKStSvXx/JyckFhk/5HEWltZynT59OxT8LFy4sVGHh/fv3AQC9e/em58qXL69YhWhxwqDFMSoqCh999BHFrnn/C4A8pfFRUVH0RV20aBEtBnxCB48T9+7dW/aRLMCbsmk+WQCQwqXqLviOHTuoveLBgwdUlXfw4EHZ7QHenKzjx4+nKfUXL17EpUuXKBypPXz3+vXrGosi7yHk47XkJCIignJNdevWpSqyL7/8UqMi78WLF3SM+MnDW0nq1KlDodTisjACUoWbuuqGklJd7wqJiYno0aOHRp6Oy7F99tlnBV5MeXiftxJx5M5HcXg7RnR0dL6LY1pamkafo5I1DMeOHaOQZXx8PH23eDW5LmrXro2pU6fStBg+XF0p1q1bRzf8s2bNwtWrVwG8mcLBb2Ktra3x999/A5B6WKOioijE+ejRI9reL7/8Qr3Cxmb+/PkkSs5R6rtmUCuHLuk3ftHs3bu3hl5qTEwMlVDzSRz8Zzc3N1oclJIm4gUiLVq0wJUrVwBI7Q5nzpwBIOUM5syZQ3dIo0aNooXUGNMv+Jdx7dq1WL58uc52By7T1ahRIwDAhAkT6IRUIlem3u6gzhdffKEx3y01NZXKqgFpYeR3lEWQZlOMR48ewdfXF0ePHgUgeZG///67IZt6r1o57O3t822z6dKlC10gu3btqtEqFBISgvXr1wMADh06BODNCLWVK1dSK5ScqLd76corpqWlaXjAxpCP49e006dP04SL+Ph4tGjRgs6X7OxsGj3Vrl07o9YITJgwIV8ZzFKlSpGec5UqVSiCVqZMGfzzzz/0PgsLC0yYMAGAVPOg5IKemZlJHjdjDJGRkVi5ciUASSCGCwQwxtC8eXNyKHhEzgBEK4dAIBAIBPpgsAhAVFQUTTvQnq6h/bP6sGMedp04caJRq1Kzs7Np34cOHaKS/tu3b8PKygoxYzfvAAAX90lEQVSTJ08GAJOW9j98+JBaTNatW0fP8+PIcxsVKlRQ3BZenj5jxow8UwR0YWFhgSlTpsgxK9EgeHgvPDwcjRs3RlJSEgApXM097iVLluDRo0cUPtyzZ49eMmk6eK88x5UrV2LUqFFv/WNHR0eNaMq1a9c06gQqVKhAnrjcA3o5fH/Vq1fXaOpXb/oH3qQuiuNcR2OTm5tLIiHR0dHk3e7evVvj3G7UqBFNEbG1tUXFihUpvePr6wt7e3tF7eS29O3bl9SEAGh4sOqYm5sjPDycpECLgPxTObhEU3p6uka4Q73Ixt/fn3KSKpVKkbyivvCFx8XFhQa2uru7Y/ny5UVSq3mfiY+Ppy9fVlYWmjRpolNy7fPPPzfaMGNdcFWNsWPH5lvYVbduXXzyySekM1mEfON7tTjm5uZiy5YtdAG9e/cupTsK3JjajbCNjQ0OHDigeFuC+mfLv4d8TBWnuA47Lm4kJydrtJS4uLhQPrJChQpGl3989eoVAElCs6CbbK7KtX//frlynyKsKhAIBAKBPphcW1UgkAOuABISEoKkpCQK63l6etJMPXt7+yLp46rxXnmO2rx+/ZoK2a5fv15gQQsvCBs/frxRVJq4LbwgjcPDqBMnTqRKW8G7yT///IMVK1YAADZt2gQrKyuaKzl27FhqEeJtMzJQvIYdCwTvMO/14igQ/I8hwqoCgUAgEOiDWBwFAoFAINBCLI4CgUAgEGghFkeBQCAQCLQQi6NAIBAIBFqIxVEgEAgEAi3E4igQCAQCgRZicRQIBAKBQAuxOAoEAoFAoIXsi+PmzZthZmYGMzMzLFq0SPFZaoUhKSkJSUlJGDNmDCIjIxEZGYkxY8ZgzJgxaNq0KZo2bQozMzMMHToUQ4cOxf79+5GRkWEye2NiYhATEwOVSgWVSgUvLy94eXlhxYoVuHHjBm7cuGEy2/LjxIkTOHHihMZzW7duxaRJk+h7YWZmhuDgYAQHB8u+//nz50OlUqF169Zo3bo1HTuVSoXPP/8cjx8/Rm5uLnJzc/Hy5UuNB2MMb1GMEgiKzJ49ezQmiqjz6NEjnD9/HmPHjsXYsWNRvnx5VKtWDdWqVaOh8QLjIJt8HNe27Nmzp8YYFEtLS3z33XcApMG+X331FQCgadOmhbfWAPgQ15EjR+LcuXMAdI9AUR+rpY6DgwPGjRsHAPD391fS1DzExMQAgM6J53yixGeffYbFixejbNmyRrVNm/j4eHTt2pU+e/WJF0+fPiXFfc6PP/4IADQqTC7++OMPdOrUCQ8ePND5evny5WmE1enTpzVemz17NgBg2rRpb9uNkI8rBNeuXaPFYOjQobC0tMTly5dNYYpJ4TeNnTt3hqWlpcbkk99++43eoz6uSZ3OnTvTUGmBrAj5OIFAIBAI9MFcrg1xj0Hda7SxsUFOTg7diTPGsHv3bgBS+FWGIZVvZfr06QCA0NDQfL3Dgvj7778pNGxsz3HLli35vvb8+XMA0lDkiIgI3Lx5E4A0ANSYnD9/HgDQqVMnmpcJAC9evDCqHRxnZ2ds3rwZw4cPByB9fuo8ePAgj8fIuXTpkuL2ve/w8//MmTOYN28eACAhIQGPHj2i95QqVQoXLlwAADRv3lyv7a5evRoHDhzAgQMH8rzWrFkzJCQkFNV0wtbWFpmZmbJtDwAyMjIwfvx4ANK58eLFC5pHmZ2dnW8438zMjCbJ9O7dW1ab5OTp06cAgBIlSsg5LYP4999/AQCVKlWi53x8fDBjxgw0btxY9v0BMoZV+QfPh84CQGZmJpYuXYoZM2ZIG1MbjmppaYmwsDB88sknhbe6EPCp1+3atcOTJ08AaC6O/fr1e+uXjp/AfPSRsdAOq/ILvouLCw1z3bt3L7KysmixVJ/UbgymTp0KAAgODtb7psPV1ZXCSBUqVFDELr59b29ves7d3R1NmzbFvXv3AADW1tYa4V/+3dXjGIqwqhb379/HpEmTcOTIEQDA7du33+xU7bznREZGAgA++ugjvbZfq1YtpKamGmRbly5dABT8uX799dcwM5MCaTVq1ICTk5NB+1InKysL169fBwAMGDCABgnrgo/+qlWrFkaMGEG2NmzYEB9//HGRbdGX3NxcAMDVq1dRrVo1ej4pKYmunzz3yVNWp0+fxuHDhwEAFStWpO+AnIsW/+xr1qypcc6am5vTYORx48YZujCLsKpAIBAIBPogWwxu//799HNgYCAAwMrKCgEBAbTSb968GUlJSQAkN7xXr16UfK5atapcpmjg7OwMAAgICKAQqzq//fYbGjZsqE8RhtH5888/NX7nYei+fftSYdM333yDe/fuoUSJEka3Lzs7G5s2bXrr+6ytrdGtWzeKLjg6OirmMXJ4uFedxYsXw83NTdH9/i/Aw+fff/89tm7dCgB4+fKlRug0P6ytrbFjxw60atWqUPuMi4vTCNtPmzaN9j1y5EgEBATk+7c1atQAAPIMjcHNmzfRo0cPut7pokOHDgAkz/bTTz8FALRo0cIo9uUH9wC7du1q0N/fvn2bPF05Q9M7d+6knydNmgRAsnH69On49ttv6T08lN++ffsi71OWxfHw4cMaB4K75oA0rZkbb29vTwvUgAEDkJmZiXLlyslhwluZNm0aufmDBg1CdnY2AODJkyeYPn064uPjAQDLly+nuLax83fa6FPRq1S8XR9SU1N1Vv5yevbsCUAKvbZs2dJYZgEATp48mee5ypUrG9WG943du3dj8eLFuH//PgDgypUr9BpjDM7OzvQ5t2zZEk2aNMmzjfLlyxsUsqxQoQIqVKhAubmXL1/Sa7Vq1ULNmjULvU0lyc7OLnBh/Prrr7F48WIAsk60LxInTpxA//796fdy5crRDYl6tXm9evXQqVMnyhuXK1cOPj4+AKQb344dO8pu29mzZwFIYVueq23evDmOHj1K6821a9dQv3592fYpwqoCgUAgEGghW0FOrVq1AECjuTUzMxPW1taG2qYYf/zxB4UlucfIj0O1atXQrFkzANBZGWdM+J1n69atkZ2dTX1Rffv2NaVZdNfu5+dHoS3togtra2uqCjW2d5uZmUm9jBkZGVRQdfbsWZQuXVqOXfzPFOT89ddfFPnZtWsXAOnuHQCcnJzQrVs3AFIlZb169eSyM194f2SjRo3g4OAAQKqG5RWdxYWkpCSdnjMgnRvHjx8nL4cX45gKXmDTrl07qnr38vJCSEgIHe+cnBx6v7u7u0ZRjNLMnDmTwqVdu3aljgcZ0Xk+mzZuaCKcnZ1x/PhxAMCoUaMQGhpKJeh///03qeIEBgZi9uzZJguv8kWlUaNGiI2NpS+FqRfHlJQUAKCFURdt2rQxysVSF5GRkRrKRjwMI9PC+D8BvzEbN24cNa9bWFhg6NChcHd3BwAMHjzY6Hapf/ddXV0BoNgtjIDkLDRv3pxCj+pkZWXBxcUF/fr1AwBs3LjRJKHVJ0+eYN++fdRNwBdGAJgzZw6srKwKnRtWgtjYWPp5yJAhRtuvbJ7j+vXrAQATJ06khaZ169YahSKMMVLLcXNzg62tbaENVoLr169TAlc7h7Z27VqjfiC6cHd3R2xsLBWTnD592mQL9qpVqyhXol6arqtcny9KU6dONZoiEiAVLv3+++8ApAWRt73w4iwZeK89x6SkJHh6egKQCiw8PDwASAU4bdu2Vc46PeARqtTUVGq9GTVqlClNypf4+Hj06tULgLQQ8ZvFW7duabS6VK9eHUFBQQCAL774QnG7eH1I165dER0drfM97u7u2L9/v0ZfoSmIj49H69atqR1HvfBTRkQrh0AgEAgE+iCb+8HveMzNzcnT4nfsHMYYlQh/+umnqF27Nn744QcAMFrVqi5q165NJcxdunTRUFXx8/PDtWvXAEihBlPg4eGB2NhYEgVISkqS0wsqFIcOHSqwmVkdXn595swZHD58GA0bNlTSNOLhw4f0s0ql0vD8u3XrRuFVb29vqnI05fevuMDzSt9//72GZ8Nzx5mZmXjx4kWxqa7kzebu7u4Uhfrwww9NaZIGLi4uSEtLy/P8ixcvsGzZMmpeT0tLI43hBg0aKN5uNHbsWAAgr5Efu3LlylFoNTo6GgcOHICfn5+itryNixcv4uXLlxoVzrxamkc9eVhd7lYd2cKq6uzbtw+AVH69bds2en7FihV5Qm9c+aB69eqG7Ep2UlJSqOeIFxfxY/Ttt9+SYLYxw5qbNm3SuMCfP3/eZItj79696fNVR1dYVZ3KlSvj6NGjAJQv0HFxcdHZ56gLXqxz6NChwrR6vJdhVZ5LbtWqlc6eRcYYRo4ciRUrVihjnR5EREQAkNqEuCpU6dKlSVFGV16ZF985OjqiT58+tBgURkZSCfbs2QNAamvjcot+fn5Ys2aNovsdOXIkAOk736tXL+oRrVixIrXiJCYmokGDBiaXVOzatSsOHjyooXLExdd5YeD8+fMBgArHDECEVQUCgUAg0AdFPMf8SEpKouotHobl5cwBAQGKJqNTUlJQp04dvd7Ly5e9vLyQlpamIVjOw03GTFQnJibC1dWV7pSXL19Od39K4OfnR3e1wJtw8pgxY7B69Wqdzc3t2rWDp6cnfb59+vTJMzaKF20NGjRIIcsl9uzZg88//xyAFHKpUqUKAKkILCYmhpSH1MXRnZ2daaSZHlGB99Jz5Pz555+Ii4sDICnT8Kpk7k3yAp0VK1YYXW+YExwcjHXr1gGQPkeuNqNrFBZv1+KN7MOGDQMgjc/i7RYffPCB4jbnR7ly5SgVYGFhgczMTEXtef36NQBJpczKykrjNR7SjY2NLVaeI8fW1pa8Ww8PD0yePJlai+Lj40kNqZDoPp/5gNd8HrJz9+5ddvfuXfbxxx8zMzMzetSsWVP2fe3evZvZ2dkxOzs7tnr16kL//eLFi5mFhQVTqVRMpVIxMzMzFhYWxsLCwmS39W3Y2tqSHd27d2evXr1ir169knUfS5cuZUuXLmXm5uYan82xY8fYsWPH9NpGSkoKS0lJYdWqVdPYhpmZGdu4cSPbuHGjrDbnR3p6OktPT2eZmZl5XouLi2NxcXFsxIgRDNKCwQCw2NhYFhsbq8/m33beFNeHQRw5coQdOXKENWvWjL6DKpWKDR482NBNysL9+/fZ/fv32a1btwp8X3x8PIuPj2ezZs1irVu31vg/zJ07l82dO5e9fv3aSFbnxdbWVuN7mJ2dLfs++PVi8uTJbNOmTWzTpk063+fq6spcXV0ZABYUFCS7HYXl+vXr7MKFC/S4efMmvfbq1SvWsWNHOm7nzp0zdDc6zxej9wNwj6tGjRo4c+YMPZ+VlUUJYt5HVRSioqIwcOBA8g4MGWkzfvx4hIeHU+IfkLenKjIyEsnJyfR727Zt9eoNDAsLIy9SzjtMrrqvLv/n4OBQqLsx/plqt8RYW1sbeldnELxBXBcuLi4AgClTpmg8L/ogdcNz8PPmzUPfvn1JUox72qaCn4tvOye5XmmLFi0wZcoUmsrSq1cvmipjbm5u9JF0+bFt2zYMHTpU1m3OnTsXALBw4UK9B01z+UdTUlCBVYkSJWBjY6PYvkXOUSAQCAQCLUymkDNnzhyNSlYrKytZS/3T09M1ckrbt2+nqrX8ZJ100bNnTw3P8csvvwQALFmyhBqlCwuvsvL29qY8zsiRI02iOPI2WrVqpXeuFkC+lYyffPKJ4rM79YXna7lQAKdu3bqmMOedoXPnzpg9ezYmTJgAQMrjc/USrlZT3LGwsKCoQlhYGE3jCQoKousF9yb1hXuiCxYsoHw2F73gv9vb25P84/Dhw2FpaYkdO3YA0Gw9AqCIstQvv/wCQPK28ssTBwcHU4StdOnSJpe1extZWVkIDw+Hvb09AGjMn5SF/OKtTKGcI+fhw4eK5xzr16+vkV8oV64cK1euHBs9ejTlnR49elTgNmbPnk0xbZVKxZycnJiTk5Ms9h09epRsKlmyJBsxYgRLTExkiYmJed47cOBAjf/L1atX2dWrV2Wxg3Pz5k128+ZNZmVlRZ+Lvb0927NnD9uzZ89bj5W3tzeztLRklpaWGp+ttbU1O3HiRJFse/XqFWvWrBmrUqUKq1KlCmvSpAmrVKkSPbiNBREdHc369u1LdkEtz7NgwQKWm5vLcnNz9THH1LlDo+Yc1Xnx4gVr164da9euHVOpVOzMmTPszJkzcmzaJJw+fZqdPn2amZmZMRsbG2ZjY8NSU1MLtY0rV66wK1euaHyfivJQIufo4+PDfHx8GACqLWCMsefPn7PAwEAWGBjILCwsyIbRo0fLboPcREdHMwDM19eX+fr6FmVTOs8XEVYVCAQCgUALo4dV//rrLwDA0qVLFd/X3r174eXlBUBSoeDhixUrVlD4r2HDhqhUqRIN6GzcuDGViD979gxxcXHULKxSqSg0IgedOnXC999/DwCYPn06Vq1aRaGW//znP1QwUq9ePQ1VfP5/A0DKGnLA1WKGDBlCx+fu3bs0q61t27aoUKECJcEDAgKoKfvkyZOIiIjQmLPHad++fZFDqowx3L59G3fu3AEADWHxESNGwNvbW+ffRUZGUlvKhg0b8rSX8OM3duxYkzeFFyd40UadOnWowR6QmrD5sNlTp06Res5HH32kuE1r1qyhVIZcoiG8LYkxRuE57fYGY8D3HRgYqEhhGJ80tGvXLowbNw6AJDR++/ZtjfQWb4HiYuTFEa7dzUPicl4DNcjPpWSFDMPw0vm2bdsyW1tbnQ8bGxtmbW3NrK2t85T529rassOHD7PDhw8XxT3Ow6VLl9ilS5eYr6+vzpAff6i3a+T3mqurK3vy5Al78uSJrDYyxlhOTg7r1q0btZ6oVCpmbm7OzM3NNdpJ+CM4OJgFBwfLbgdjUpioUaNGrFGjRqxUqVI6j4muY6T9XNu2bVnbtm1ZRkaGLHZFRETQ8YFaGMrCwoKVLVtW50M7fAqAVaxYkVWsWJHFxsYWJpSqjqnDo4qGVR88eEDn6YEDB9i9e/foMWbMGFa9enVWvXp1VqlSJZaQkMASEhIKefgMw8/Pj9Ia6enpRd5eeHg4c3Z2Zs7OzszS0pJt2bKFbdmypdDb4d+h3r17GxRG9fLyouuUUjx79ow9e/aMdenSJV87OnTowO7cucPu3LmjmB1ycOLECXbixAkGgLm7u7OcnByWk5NTlE2KsKpAIBAIBPogm0LOqVOnAEi9geo8e/aMevkYy3+skb+/PykfKAVXb1m4cCH143FtV34cdIXW+NiZlStXKq6Mw/sDR4wYgbCwsHzfx/uWFAsp/H9cXV2pgo0rjOhC+7MtWbIkzp49C+BNn5kc8MrhFStW0Gd49+5dvf62c+fO6NOnD83RK8Ig7nc1/qrX+fzvv//q1JnV/ow7d+6soV6iNH/++SelP5o3b05zJgvLkiVLAEihQx6i8/b2RmhoaJHsu3PnDlWF6hOW5IpgU6dONVql9LNnz6iPPCEhAe7u7vR7YGBgYfSFTUJubi66d+8OQKo2j4qKIn3kIqDzfFZcPu7+/fs0QfzkyZM035FLUvEcpLGFx3n59ebNm3Hjxg16/vr161Tq3aNHD9SuXdto0yTUef36NS0uu3btwtOnT/Hrr7/S68ZaHAEpVwdIs/22bNmCixcv5nkPv3CqN9j37t1bUbt4Htbf358mwKSkpMDLy4sa121sbEho2tPTU6684nu9OD558oTanfjNI/DmM+bnamxsLOzs7BQwM3/4ZJrOnTvj6dOnAKQ8Gc9BOzk5wdXVlWTQQkJCKE99+/Zt7N69m/LidnZ2NJvU19dXlqkO/HoaExODOXPm6LzBHT58OLy9vUmGz9jiE7xlJTc3FxYWFrJPs1ACLjzh7e2NkydPApAciJUrV8qxedMsjgLBe8h7vTi+fPmS1G+6detGvbh2dnbw8fHBrFmzAMirFlVYEhMTaWHbunUrKUbpA48ELV++nAphBMUbXiA4atQomuoTHx8v1/g0MZVDIBAIBAJ9EJ6jQFB43mvP8V3jxo0bNGni2rVrNLicw0OsrVq1AgBSiHkXwokCCT5r1M/Pj5TOeNuJDIiwqkAgE2JxFAjeH0RYVSAQCAQCfRCLo0AgEAgEWrxNPu5dDR8JBIK8iPNZINAT4TkKBAKBQKCFWBwFAoFAINBCLI4CgUAgEGghFkeBQCAQCLQQi6NAIBAIBFqIxVEgEAgEAi3+H2Xc9kXEz+WyAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_digits(instances, images_per_row=10, **options):\n",
    "    size = 28\n",
    "    images_per_row = min(len(instances), images_per_row)\n",
    "    images = [instance.reshape(size,size) for instance in instances]\n",
    "    n_rows = (len(instances) - 1) // images_per_row + 1\n",
    "    row_images = []\n",
    "    n_empty = n_rows * images_per_row - len(instances)\n",
    "    images.append(np.zeros((size, size * n_empty)))\n",
    "    for row in range(n_rows):\n",
    "        rimages = images[row * images_per_row : (row + 1) * images_per_row]\n",
    "        row_images.append(np.concatenate(rimages, axis=1))\n",
    "    image = np.concatenate(row_images, axis=0)\n",
    "    plt.imshow(image, cmap = matplotlib.cm.binary, **options)\n",
    "    plt.axis(\"off\")\n",
    "\n",
    "\n",
    "# 查看数字3和数字5的例子\n",
    "cl_a, cl_b = 3, 5\n",
    "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n",
    "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]\n",
    "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]\n",
    "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]\n",
    "\n",
    "plt.figure(figsize=(8,8))\n",
    "plt.subplot(221); \n",
    "plot_digits(X_aa[:25], images_per_row=5)\n",
    "plt.subplot(222); \n",
    "plot_digits(X_ab[:25], images_per_row=5)\n",
    "plt.subplot(223);\n",
    "plot_digits(X_ba[:25], images_per_row=5)\n",
    "plt.subplot(224); \n",
    "plot_digits(X_bb[:25], images_per_row=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 左侧两个是被分类为3的图片\n",
    "# 右侧两个是被分类为5的图片\n",
    "# 大多数错误分类的图片看起来还是非常明显的错误\n",
    "# 原因：SGD是一个线性模型，它所做就是为每个像素分配一个各个类别的权重，当它看到新的图像，将加权后的像素强度汇总，从而得到一个分数进行分类\n",
    "# 数字3和5在一部分像素位上有区别，所以分类器很容易将其弄混\n",
    "# 通过上面图像，如果书写3 的连接点左移，分类器可能将其分类为数字5，这个分类器对图像位移和旋转敏感\n",
    "# 减少混淆的方法之一，就是对图像进行预处理，确保位于中心位置并且没有旋转"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多标签分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 为每个实例产生多个类别 ，例如 照片识别多个人脸\n",
    "# 分类器经过训练可以识别小红，小白，小军，一张照片 里有 小红，小白\n",
    "# 经过分类器，应该输出[1,1,0]， 是小红，是小白，不是小军\n",
    "# 输出多个二元标签的分类系统称为多标签分类系统"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "y_train_large = (y_train >= 7)\n",
    "y_train_odd = (y_train % 2 == 1)\n",
    "y_multilabel = np.c_[y_train_large, y_train_odd]\n",
    "\n",
    "knn_clf = KNeighborsClassifier()\n",
    "knn_clf.fit(X_train, y_multilabel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# knn支持多标签分类，不是所有的分类器都支持\n",
    "knn_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # 评估多标签分类器方法很多，方法之一就是测量每个标签的F1分数，或者其他二元分类器指标，然后简单平均\n",
    "# y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_multilabel, cv=3)\n",
    "# f1_score(y_multilabel, y_train_knn_pred, average=\"macro\")\n",
    "0.977090"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 上面假设了所有标签都同等重要，也可以给每个标签设置一个权重（该目标标签实例的数量），设置average='weighted'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多输出分类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 例子：构建一个系统去除图片中的噪声，输入一张有噪声的图片，它将输入一张干净的数字图片，分类器输出是多个标签，一个像素一个标签，每个标签多个值0到255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 增加噪声，目标将图片还原为原始图片 创建训练集和测试集\n",
    "noise = np.random.randint(0, 100, (len(X_train), 784))\n",
    "X_train_mod = X_train + noise\n",
    "noise = np.random.randint(0, 100, (len(X_test), 784))\n",
    "X_test_mod = X_test + noise\n",
    "y_train_mod = X_train\n",
    "y_test_mod = X_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "some_index = 5500\n",
    "plt.subplot(121);plt.imshow(X_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.subplot(122);plt.imshow(y_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "knn_clf.fit(X_train_mod, y_train_mod)\n",
    "clean_digit = knn_clf.predict([X_test_mod[some_index]])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(clean_digit.reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
